Wed Apr 29 10:20:40 1998 John Metzler <jmetzler@cygnus.com>

	* nec4102rom.c : New file implements rom monitor adapter for
        nec-vr4102 board. This board hosts the vr4111 chip. This file
        required extenstions to the monitor_ops structure, hooks for wiat
        filter, new flags. This version does not support more than one
        breakpoint and resuming after a breakpoint in 16 bit mode is
        completely disfunctional.  * monitor.h : Defined additional hooks
        for dmpregs, confinuer_hooks and wait_filter. These additions
        require that all rom monitor interfaces be recoded to to
        initializa monitor ops using assignments rather than static
        structure initialization.  Added new bits to flags
        MO_EXACT_DUMPADDR, MO_HAS_BLOCKWRITES
        * monitor.c (RDEBUG): Conditional tracing throughout the file.
        (fromhex): Now recognized upper cse hex digits
        (monitor_printf_noecho):
        (monitor_readchar): Tracing interferes with input timing.
        (monitor_open): Register different memory write functions with
        dcache_init if MO_HAS_BLOCKWRITES.
        (flush_monior_dcache): Added as an additional utilty.
        (monitor-resume): Call continue hook if one has been supplied.
        (monitor_wait_filter): New function Factored out of monitor wait
        and used if alternate wait-filter has not been provided.
        (monitor_wait): call alternate wait filter if provided.  Call
        monitor_dump_regs, a new function factored out from inline code.
        (monitor_dump_block): A new function used as a utility when
        monitors must dump several blocks of registers using different
        commands.
        (monitor_dump_regs): Call alternate function if provided. Uses new
        hook in monitor.h.
        (monitor_write_memory): Engage previouly added hook
        MO_FILL_USES_ADDR.
        (monitor_write_even_block): new function supports writing long
        blocks of 4byte words.
        (longlongendswap): new internal function
        (monitor_write_memory_longlongs): new function writes large blocks
        using command to enter a long long.
        (monitor_write-memory_block): new Function figures out which block
        mod to use.
        (monitor_read_memory): Can now handle dump formats in which the bytes
        preceeding the requested data is not printed.
	* monitor.h: Added new fields to the structure

1 files changed, 473 insertions, 58 deletions

diff --git a/gdb/monitor.c b/gdb/monitor.c
index 03bfa59..bd07a2a 100644
--- a/gdb/monitor.c
+++ b/gdb/monitor.c
@@ -62,6 +62,8 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 static char *dev_name;
 static struct target_ops *targ_ops;
 
+static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
+
 static int readchar PARAMS ((int timeout));
 
 static void monitor_command PARAMS ((char *args, int fromtty));
@@ -91,9 +93,15 @@ static void monitor_stop PARAMS ((void));
 
 static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
 static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
-
+static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
+					       char *myaddr,int len));
+static int monitor_write_memory_block PARAMS((
+					      CORE_ADDR memaddr ,
+					      char * myaddr ,
+					      int len)) ;
 static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat,
 					  char *buf, int buflen));
+static void monitor_dump_regs PARAMS((void)) ;
 #if 0
 static int from_hex PARAMS ((int a));
 static unsigned long get_hex_word PARAMS ((void));
@@ -110,6 +118,16 @@ static int in_monitor_wait = 0;	/* Non-zero means we are in monitor_wait() */
 
 static void (*ofunc)();		/* Old SIGINT signal handler */
 
+/* Extra remote debugging for developing a new rom monitor variation */
+#if ! defined(EXTRA_RDEBUG)
+#define EXTRA_RDEBUG 1
+#endif
+#if EXTRA_RDEBUG
+#define RDEBUG(stuff) { if (remote_debug) printf stuff ; }
+#else
+#define RDEBUG(stuff) {}
+#endif
+
 /* Descriptor for I/O to remote machine.  Initialize it to NULL so
    that monitor_open knows that we don't have a file open when the
    program starts.  */
@@ -141,10 +159,75 @@ fromhex (a)
     return a - '0';
   else if (a >= 'a' && a <= 'f')
     return a - 'a' + 10;
-  else 
-    error ("Invalid hex digit %d", a);
+  else
+    if (a >= 'A' && a <= 'F')
+      return a - 'A' + 10 ;
+  else error ("Invalid hex digit %d", a);
 }
 
+/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
+
+   This function exists to get around the problem that many host platforms
+   don't have a printf that can print 64-bit addresses.  The %A format
+   specification is recognized as a special case, and causes the argument
+   to be printed as a 64-bit hexadecimal address.
+
+   Only format specifiers of the form "[0-9]*[a-z]" are recognized.
+   If it is a '%s' format, the argument is a string; otherwise the
+   argument is assumed to be a long integer.
+*/
+  
+static void
+monitor_vsprintf (sndbuf, pattern, args)
+     char *sndbuf;
+     char *pattern;
+     va_list args;
+{
+  char format[10];
+  char fmt;
+  char *p;
+  int i;
+  long arg_int;
+  CORE_ADDR arg_addr;
+  char *arg_string;
+
+  for (p = pattern; *p; p++)
+    {
+      if (*p == '%')
+	{
+	  /* Copy the format specifier to a separate buffer.  */
+	  format[0] = *p++;
+	  for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
+	       i++, p++)
+	    format[i] = *p;
+	  format[i] = fmt = *p;
+	  format[i+1] = '\0';
+
+	  /* Fetch the next argument and print it.  */
+	  switch (fmt)
+	    {
+	    case 'A':
+	      arg_addr = va_arg (args, CORE_ADDR);
+	      strcpy (sndbuf, paddr_nz (arg_addr));
+	      break;
+	    case 's':
+	      arg_string = va_arg (args, char *);
+	      sprintf (sndbuf, format, arg_string);
+	      break;
+	    default:
+	      arg_int = va_arg (args, long);
+	      sprintf (sndbuf, format, arg_int);
+	      break;
+	    }
+	  sndbuf += strlen (sndbuf);
+	}
+      else
+	*sndbuf++ = *p;
+    }
+  *sndbuf = '\0';
+}
+
+
 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
    Works just like printf.  */
 
@@ -168,11 +251,14 @@ monitor_printf_noecho (va_alist)
   pattern = va_arg (args, char *);
 #endif
 
-  vsprintf (sndbuf, pattern, args);
+  monitor_vsprintf (sndbuf, pattern, args);
 
+#if 0
   if (remote_debug > 0)
     puts_debug ("sent -->", sndbuf, "<--");
-
+#endif
+  RDEBUG(("sent[%s]\n",sndbuf)) ;
+  
   len = strlen (sndbuf);
 
   if (len + 1 > sizeof sndbuf)
@@ -204,13 +290,14 @@ monitor_printf (va_alist)
   pattern = va_arg (args, char *);
 #endif
 
-  vsprintf (sndbuf, pattern, args);
+  monitor_vsprintf (sndbuf, pattern, args);
 
+#if 0
   if (remote_debug > 0)
     puts_debug ("sent -->", sndbuf, "<--");
-
+#endif
+  RDEBUG(("sent[%s]\n",sndbuf)) 
   len = strlen (sndbuf);
-
   if (len + 1 > sizeof sndbuf)
     abort ();
 
@@ -220,6 +307,7 @@ monitor_printf (va_alist)
      just output, but sometimes some extra junk appeared before the characters
      we expected, like an extra prompt, or a portmaster sending telnet negotiations.
      So, just start searching for what we sent, and skip anything unknown.  */
+  RDEBUG(("ExpectEcho\n"))
   monitor_expect (sndbuf, (char *)0, 0);
 }
 
@@ -285,6 +373,9 @@ readchar (timeout)
       if (c >= 0)
 	{
 	  c &= 0x7f;
+#if 0
+	  /* This seems to interfere with proper function of the
+	     input stream */
 	  if (remote_debug > 0)
 	    {
 	      char buf[2];
@@ -292,6 +383,8 @@ readchar (timeout)
 	      buf[1] = '\0';
 	      puts_debug ("read -->", buf, "<--");
 	    }
+	  
+#endif	  
 	}
 
       /* Canonicialize \n\r combinations into one \r */
@@ -320,11 +413,12 @@ readchar (timeout)
     return c;
 
   if (c == SERIAL_TIMEOUT)
-#ifdef MAINTENANCE_CMDS
+#if 0 /* MAINTENANCE_CMDS */
+    /* I fail to see how detaching here can be useful
     if (in_monitor_wait)	/* Watchdog went off */
       {
 	target_mourn_inferior ();
-	error ("Watchdog has expired.  Target detached.\n");
+	error ("GDB serial timeout has expired.  Target detached.\n");
       }
     else
 #endif
@@ -350,6 +444,7 @@ monitor_expect (string, buf, buflen)
   int obuflen = buflen;
   int c;
   extern struct target_ops *targ_ops;
+  RDEBUG(("MON Expecting '%s'\n",string)) ;
 
   immediate_quit = 1;
   while (1)
@@ -414,7 +509,7 @@ monitor_expect_regexp (pat, buf, buflen)
 {
   char *mybuf;
   char *p;
-
+  RDEBUG(("MON Expecting regexp\n")) ;
   if (buf)
     mybuf = buf;
   else
@@ -465,6 +560,7 @@ monitor_expect_prompt (buf, buflen)
      char *buf;
      int buflen;
 {
+  RDEBUG(("MON Expecting prompt\n"))
   return monitor_expect (current_monitor->prompt, buf, buflen);
 }
 
@@ -593,7 +689,8 @@ monitor_open (args, mon_ops, from_tty)
       monitor_stop ();
       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
         {
-        monitor_expect_prompt (NULL, 0); 
+	  RDEBUG(("EXP Open echo\n")) ;
+	  monitor_expect_prompt (NULL, 0); 
       }
     }
 
@@ -631,8 +728,10 @@ monitor_open (args, mon_ops, from_tty)
 
   monitor_printf (current_monitor->line_term);
 
-  remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
-
+  if (current_monitor->flags & MO_HAS_BLOCKWRITES)
+    remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
+  else
+    remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
   start_remote ();
 }
 
@@ -673,6 +772,7 @@ monitor_supply_register (regno, valstr)
   char *p;
 
   val = strtoul (valstr, &p, 16);
+  RDEBUG(("Supplying Register %d %s\n",regno,valstr)) ;
 
   if (val == 0 && valstr == p)
     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
@@ -689,12 +789,15 @@ monitor_supply_register (regno, valstr)
 
 /* Tell the remote machine to resume.  */
 
+int flush_monitor_dcache(void) {  dcache_flush (remote_dcache); }
+
 static void
 monitor_resume (pid, step, sig)
      int pid, step;
      enum target_signal sig;
 {
   /* Some monitors require a different command when starting a program */
+  RDEBUG(("MON resume\n")) ;
   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
     {
       first_time = 0;
@@ -708,7 +811,9 @@ monitor_resume (pid, step, sig)
     monitor_printf (current_monitor->step);
   else
     {
-      monitor_printf (current_monitor->cont);
+      if (current_monitor->continue_hook)
+	(*current_monitor->continue_hook)() ;
+      else monitor_printf (current_monitor->cont);
       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
 	dump_reg_flag = 1;
     }
@@ -724,6 +829,7 @@ parse_register_dump (buf, len)
      char *buf;
      int len;
 {
+  RDEBUG(("MON Parsing  register dump\n")) 
   while (1)
     {
       int regnamelen, vallen;
@@ -803,6 +909,40 @@ monitor_wait_cleanup (old_timeout)
   in_monitor_wait = 0;
 }
 
+
+
+void monitor_wait_filter(char * buf,
+			 int bufmax,
+			 int * ext_resp_len, 
+			 struct target_waitstatus * status
+			 )
+{
+  int resp_len ;
+  do
+    {
+      resp_len = monitor_expect_prompt (buf, bufmax);
+      * ext_resp_len =resp_len ;
+
+      if (resp_len <= 0)
+	fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
+    }
+  while (resp_len < 0);
+
+  /* Print any output characters that were preceded by ^O.  */
+  /* FIXME - This would be great as a user settabgle flag */
+  if (remote_debug ||
+      current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+    {
+      int i;
+
+      for (i = 0; i < resp_len - 1; i++)
+	if (buf[i] == 0x0f)
+	  putchar_unfiltered (buf[++i]);
+    }
+}
+
+
+
 /* Wait until the remote machine stops, then return, storing status in
    status just as `wait' would.  */
 
@@ -820,8 +960,10 @@ monitor_wait (pid, status)
   status->value.integer = 0;
 
   old_chain = make_cleanup (monitor_wait_cleanup, old_timeout);
+  RDEBUG(("MON wait\n"))
 
-#ifdef MAINTENANCE_CMDS
+#if 0 /* MAINTENANCE_CMDS */
+    /* This is somthing other than a maintenance command */
   in_monitor_wait = 1;
   timeout = watchdog > 0 ? watchdog : -1;
 #else
@@ -830,6 +972,11 @@ monitor_wait (pid, status)
 
   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
 
+  if (current_monitor->wait_filter)
+    (*current_monitor->wait_filter)(buf,sizeof (buf),&resp_len,status) ;
+  else          monitor_wait_filter(buf,sizeof (buf),&resp_len,status) ;
+      
+#if 0 /* Transferred to monitor wait filter */
   do
     {
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
@@ -840,7 +987,9 @@ monitor_wait (pid, status)
   while (resp_len < 0);
 
   /* Print any output characters that were preceded by ^O.  */
-  if (current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
+  /* FIXME - This would be great as a user settabgle flag */
+  if (remote_debug ||
+      current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
     {
       int i;
 
@@ -848,21 +997,25 @@ monitor_wait (pid, status)
 	if (buf[i] == 0x0f)
 	  putchar_unfiltered (buf[++i]);
     }
+#endif  
 
   signal (SIGINT, ofunc);
 
   timeout = old_timeout;
-
+#if 0
   if (dump_reg_flag && current_monitor->dump_registers)
     {
       dump_reg_flag = 0;
-
       monitor_printf (current_monitor->dump_registers);
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
     }
 
   if (current_monitor->register_pattern)
     parse_register_dump (buf, resp_len);
+#else
+  RDEBUG(("Wait fetching registers after stop\n")) ;
+  monitor_dump_regs() ;
+#endif  
 
   status->kind = TARGET_WAITKIND_STOPPED;
   status->value.sig = TARGET_SIGNAL_TRAP;
@@ -887,9 +1040,10 @@ monitor_fetch_register (regno)
   int i;
 
   name = current_monitor->regnames[regno];
+  RDEBUG(("MON fetchreg %d '%s'\n",regno,name)) 
 
-  if (!name)
-    {
+  if (!name || (*name == '\0'))
+    { RDEBUG(("No register known for %d\n",regno))
       supply_register (regno, zerobuf);
       return;
     }
@@ -904,11 +1058,14 @@ monitor_fetch_register (regno)
 
   if (current_monitor->getreg.resp_delim)
     {
+      RDEBUG(("EXP getreg.resp_delim\n")) 
       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
       /* Handle case of first 32 registers listed in pairs.  */
       if (current_monitor->flags & MO_32_REGS_PAIRED
 	  && regno & 1 == 1 && regno < 32)
-	monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
+	{ RDEBUG(("EXP getreg.resp_delim\n")) ;
+	  monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
+	}
     }
 
   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
@@ -943,6 +1100,7 @@ monitor_fetch_register (regno)
     }
 
   regbuf[i] = '\000';		/* terminate the number */
+  RDEBUG(("REGVAL '%s'\n",regbuf)) ;
 
   /* If TERM is present, we wait for that to show up.  Also, (if TERM
      is present), we will send TERM_CMD if that is present.  In any
@@ -951,31 +1109,49 @@ monitor_fetch_register (regno)
 
   if (current_monitor->getreg.term)
     {
+      RDEBUG(("EXP getreg.term\n"))
       monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
+    }
 
-      if (current_monitor->getreg.term_cmd)
-	{
-	  monitor_printf (current_monitor->getreg.term_cmd);
-	  monitor_expect_prompt (NULL, 0);
-	}
+  if (current_monitor->getreg.term_cmd)
+    { RDEBUG(("EMIT getreg.term.cmd\n"))
+	monitor_printf (current_monitor->getreg.term_cmd);
     }
-  else
+  if (! current_monitor->getreg.term ||    /* Already expected or */
+      current_monitor->getreg.term_cmd)    /* ack expected */
     monitor_expect_prompt (NULL, 0); /* get response */
 
   monitor_supply_register (regno, regbuf);
 }
 
+/* Sometimes, it takes several commands to dump the registers */
+/* This is a primitive for use by variations of monitor interfaces in
+   case they need to compose the operation.
+   */
+int monitor_dump_reg_block(char * block_cmd)
+{
+  char buf[1024];
+  int resp_len;
+  monitor_printf (block_cmd);
+  resp_len = monitor_expect_prompt (buf, sizeof (buf));
+  parse_register_dump (buf, resp_len);
+  return 1 ;
+}
+
+
 /* Read the remote registers into the block regs.  */
+/* Call the specific function if it has been provided */
 
 static void
 monitor_dump_regs ()
 {
   char buf[1024];
   int resp_len;
-
-  if (current_monitor->dump_registers)
-    {
-      monitor_printf (current_monitor->dump_registers);
+  if (current_monitor->dumpregs)
+     (*(current_monitor->dumpregs))() ; /* call supplied function */
+  else
+    if (current_monitor->dump_registers) /* default version */
+    { monitor_printf (current_monitor->dump_registers);
       resp_len = monitor_expect_prompt (buf, sizeof (buf));
       parse_register_dump (buf, resp_len);
     }
@@ -987,6 +1163,7 @@ static void
 monitor_fetch_registers (regno)
      int regno;
 {
+  RDEBUG(("MON fetchregs\n")) ;
   if (current_monitor->getreg.cmd) 
     {
       if (regno >= 0)
@@ -1013,10 +1190,13 @@ monitor_store_register (regno)
   unsigned int val;
 
   name = current_monitor->regnames[regno];
-  if (!name)
-    return;
+  if (!name || (*name == '\0'))
+    { RDEBUG(("MON Cannot store unknown register\n"))
+      return;
+    }
 
   val = read_register (regno);
+  RDEBUG(("MON storeg %d %08x\n",regno,(unsigned int)val))
 
   /* send the register deposit command */
 
@@ -1028,17 +1208,20 @@ monitor_store_register (regno)
     monitor_printf (current_monitor->setreg.cmd, name, val);
 
   if (current_monitor->setreg.term)
-    {
+    { RDEBUG(("EXP setreg.term\n"))
       monitor_expect (current_monitor->setreg.term, NULL, 0);
-
       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
 	monitor_printf ("%x\r", val);
-
       monitor_expect_prompt (NULL, 0);
     }
   else
     monitor_expect_prompt (NULL, 0);
-}
+  if (current_monitor->setreg.term_cmd) /* Mode exit required */
+    { RDEBUG(("EXP setreg_termcmd\n")) ;
+      monitor_printf("%s",current_monitor->setreg.term_cmd) ;
+      monitor_expect_prompt(NULL,0) ;
+    }
+} /* monitor_store_register */
 
 /* Store the remote registers.  */
 
@@ -1081,10 +1264,12 @@ monitor_write_memory (memaddr, myaddr, len)
      char *myaddr;
      int len;
 {
-  unsigned int val;
+  unsigned int val, hostval ;
   char *cmd;
   int i;
 
+  RDEBUG(("MON write %d %08x\n",len,(unsigned long)memaddr))
+
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
 
@@ -1098,10 +1283,11 @@ monitor_write_memory (memaddr, myaddr, len)
 
       if (i > 4)		/* More than 4 zeros is worth doing */
 	{
-	  if (current_monitor->flags & MO_FILL_USES_ADDR)
-	    monitor_printf (current_monitor->fill, memaddr, memaddr + i, 0);
-	  else
-	    monitor_printf (current_monitor->fill, memaddr, i, 0);
+	  RDEBUG(("MON FILL %d\n",i))
+	    if (current_monitor->flags & MO_FILL_USES_ADDR)
+	      monitor_printf (current_monitor->fill, memaddr, (memaddr + i)-1, 0);
+	    else
+	      monitor_printf (current_monitor->fill, memaddr, i, 0);
 
 	  monitor_expect_prompt (NULL, 0);
 
@@ -1135,6 +1321,12 @@ monitor_write_memory (memaddr, myaddr, len)
     }
 
   val = extract_unsigned_integer (myaddr, len);
+  
+  if (len == 4)
+    { hostval = * (unsigned int *) myaddr ;
+      RDEBUG(("Hostval(%08x) val(%08x)\n",hostval,val)) ;
+    }
+
 
   if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
     monitor_printf_noecho (cmd, memaddr, val);
@@ -1144,11 +1336,14 @@ monitor_write_memory (memaddr, myaddr, len)
       monitor_printf_noecho (cmd, memaddr);
 
       if (current_monitor->setmem.term)
-	{
+	{ RDEBUG(("EXP setmem.term")) ;
 	  monitor_expect (current_monitor->setmem.term, NULL, 0);
-
 	  monitor_printf ("%x\r", val);
-
+	}
+      if (current_monitor->setmem.term_cmd)
+	{ /* Emit this to get out of the memory editing state */
+	  monitor_printf("%s",current_monitor->setmem.term_cmd) ;
+	  /* Drop through to expecting a prompt */
 	}
     }
   else
@@ -1159,6 +1354,191 @@ monitor_write_memory (memaddr, myaddr, len)
   return len;
 }
 
+
+static monitor_write_even_block(memaddr,myaddr,len)
+     CORE_ADDR memaddr ;
+     char * myaddr ;
+     int len ;
+{
+  unsigned int val ;
+  int written = 0 ;;
+  /* Enter the sub mode */
+  monitor_printf(current_monitor->setmem.cmdl,memaddr) ;
+  monitor_expect_prompt(NULL,0) ;
+ 
+  while (len)
+    {
+      val = extract_unsigned_integer(myaddr,4) ; /* REALLY */
+      monitor_printf("%x\r",val) ;
+      myaddr += 4 ;
+      memaddr += 4 ;
+      written += 4 ;
+      RDEBUG((" @ %08x\n",memaddr))
+      /* If we wanted to, here we could validate the address */
+      monitor_expect_prompt(NULL,0) ;
+    }
+  /* Now exit the sub mode */
+  monitor_printf (current_monitor->getreg.term_cmd);
+  monitor_expect_prompt(NULL,0) ;
+  return written ;
+}
+
+
+static int monitor_write_memory_bytes(memaddr,myaddr,len)
+     CORE_ADDR memaddr ;
+     char * myaddr ;
+     int len ;
+{
+  unsigned char val ;
+  int written = 0 ;
+  if (len == 0) return 0 ;
+  /* Enter the sub mode */
+  monitor_printf(current_monitor->setmem.cmdb,memaddr) ;
+  monitor_expect_prompt(NULL,0) ;
+  while (len)
+    {
+      val = *myaddr ;
+      monitor_printf("%x\r",val) ;
+      myaddr++ ;
+      memaddr++ ;
+      written++ ;
+      /* If we wanted to, here we could validate the address */
+      monitor_expect_prompt(NULL,0) ;
+      len-- ;
+    }
+  /* Now exit the sub mode */
+  monitor_printf (current_monitor->getreg.term_cmd);
+  monitor_expect_prompt(NULL,0) ;
+  return written ;
+}
+
+
+static longlongendswap(unsigned char * a)
+{
+  int i,j ;
+  unsigned char x ;
+  i = 0 ; j = 7 ;
+  while (i < 4)
+    { x = *(a+i) ;
+      *(a+i) = *(a+j) ;
+      *(a+j) = x ;
+      i++ , j-- ;
+    }
+}
+/* Format 32 chars of long long value, advance the pointer */
+static char * hexlate = "0123456789abcdef" ;
+static char * longlong_hexchars(unsigned long long value,
+				 char * outbuff )
+{
+  if (value == 0) { *outbuff++ = '0' ; return outbuff ; }
+  else
+    { static unsigned char disbuf[8] ; /* disassembly buffer */
+      unsigned char * scan , * limit ; /* loop controls */
+      unsigned char c , nib ;
+      int leadzero = 1 ;
+      scan = disbuf ; limit = scan + 8 ;
+      { unsigned long long * dp ;
+	dp = (unsigned long long *) scan ;
+	*dp = value ;
+      }
+      longlongendswap(disbuf) ; /* FIXME: ONly on big endian hosts */
+      while (scan < limit)
+	{ c = *scan++ ; /* a byte of our long long value */
+	  if (leadzero)
+	    if (c == 0) continue ;
+	    else leadzero = 0 ; /* henceforth we print even zeroes */
+	  nib = c >> 4 ;        /* high nibble bits */
+	  *outbuff++ = hexlate[nib] ;
+	  nib = c & 0x0f ;      /* low nibble bits */
+	  *outbuff++ = hexlate[nib] ;
+	}
+      return outbuff ;
+    }
+} /* longlong_hexchars */
+
+
+
+/* I am only going to call this when writing virtual byte streams.
+   Which possably entails endian conversions
+   */
+static int monitor_write_memory_longlongs(memaddr,myaddr,len)
+     CORE_ADDR memaddr ;
+     char * myaddr ;
+     int len ;
+{
+  static char hexstage[20] ; /* At least 16 digits required, plus null */
+  char * endstring ;
+  long long * llptr ;
+  long long value ;
+  int written = 0 ;
+  llptr = (unsigned long long *) myaddr ;
+  if (len == 0 ) return 0 ;
+  monitor_printf(current_monitor->setmem.cmdll,memaddr) ;
+  monitor_expect_prompt(NULL,0) ;
+  while (len >= 8 )
+    {
+      value = *llptr ;
+      endstring = longlong_hexchars(*llptr,hexstage) ;
+      *endstring = '\0' ; /* NUll terminate for printf */
+      monitor_printf("%s\r",hexstage) ;
+      llptr++ ;
+      memaddr += 8 ;
+      written += 8 ;
+      /* If we wanted to, here we could validate the address */
+      monitor_expect_prompt(NULL,0) ;
+      len -= 8 ;
+    }
+  /* Now exit the sub mode */
+  monitor_printf (current_monitor->getreg.term_cmd);
+  monitor_expect_prompt(NULL,0) ;
+  return written ;
+} /* */
+
+
+
+/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
+/* This is for the large blocks of memory which may occur in downloading.
+   And for monitors which use interactive entry,
+   And for monitors which do not have other downloading methods.
+   Without this, we will end up calling monitor_write_memory many times
+   and do the entry and exit of the sub mode many times
+   This currently assumes...
+     MO_SETMEM_INTERACTIVE
+     ! MO_NO_ECHO_ON_SETMEM
+     To use this, the you have to patch the monitor_cmds block with
+     this function. Otherwise, its not tuned up for use by all
+     monitor variations.
+   */
+
+static int monitor_write_memory_block(memaddr,myaddr,len)
+     CORE_ADDR memaddr ;
+     char * myaddr ;
+     int len ;
+{
+  int written ;
+  written = 0 ;
+  /* FIXME: This would be a good place to put the zero test */
+#if 1 
+  if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
+       {
+	 return monitor_write_memory_longlongs(memaddr,myaddr,len) ;
+       }
+#endif  
+#if 0 
+  if (len > 4)
+    {
+      int sublen ;
+      written = monitor_write_even_block(memaddr,myaddr,len) ;
+      /* Adjust calling parameters by written amount */
+      memaddr += written ;
+      myaddr += written ;
+      len -= written ;
+    }
+#endif
+  written = monitor_write_memory_bytes(memaddr,myaddr,len) ;
+  return written ;
+}
+
 /* This is an alternate form of monitor_read_memory which is used for monitors
    which can only read a single byte/word/etc. at a time.  */
 
@@ -1174,6 +1554,7 @@ monitor_read_memory_single (memaddr, myaddr, len)
   char *cmd;
   int i;
 
+  RDEBUG(("MON read single\n")) ;
 #if 0
   /* Can't actually use long longs (nice idea, though).  In fact, the
      call to strtoul below will fail if it tries to convert a value
@@ -1210,7 +1591,9 @@ monitor_read_memory_single (memaddr, myaddr, len)
      searching from the start of the buf.  */
 
   if (current_monitor->getmem.resp_delim)
-    monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
+    { RDEBUG(("EXP getmem.resp_delim\n")) ;
+      monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
+    }
 
   /* Now, read the appropriate number of hex digits for this loc,
      skipping spaces.  */
@@ -1298,6 +1681,9 @@ monitor_read_memory (memaddr, myaddr, len)
   int i;
   CORE_ADDR dumpaddr;
 
+  if (remote_debug) printf("MON read block ta(%08x) ha(%08x) %d\n",
+	  (unsigned long) memaddr , (unsigned long)myaddr, len);
+
   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
     memaddr = ADDR_BITS_REMOVE (memaddr);
 
@@ -1306,7 +1692,13 @@ monitor_read_memory (memaddr, myaddr, len)
 
   len = min (len, 16);
 
-  dumpaddr = memaddr & ~0xf;
+  /* Some dumpers align the first data with the preceeding 16
+     byte boundary. Some print blanks and start at the
+     requested boundary. EXACT_DUMPADDR
+     */
+
+  dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
+    ? memaddr : memaddr & ~ 0x0f ;
 
   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
@@ -1354,6 +1746,7 @@ monitor_read_memory (memaddr, myaddr, len)
     {
       int retval, tmp;
       struct re_registers resp_strings;
+      RDEBUG(("MON getmem.resp_delim %s\n",current_monitor->getmem.resp_delim)) ;
 
       tmp = strlen (p);
       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
@@ -1372,27 +1765,35 @@ monitor_read_memory (memaddr, myaddr, len)
       p += strlen (current_monitor->getmem.resp_delim);
 #endif
     }
-
+  if (remote_debug) printf("MON scanning  %d ,%08x '%s'\n",len,p,p) ;
   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
     {
+      char c ;
+      int fetched = 0 ;
       i = len;
-      while (!(*p == '\000' || *p == '\n' || *p == '\r') && i > 0)
-	{
-	  if (isxdigit (*p))
-	    {
-	      if (dumpaddr >= memaddr && i > 0)
-		{
-		  val = fromhex (*p) * 16 + fromhex (*(p+1));
+      c = *p ;
+
+			    
+      while (!(c  == '\000' || c == '\n' || c == '\r') && i > 0)
+	{ if (isxdigit (c))
+	    { if ((dumpaddr >= memaddr) && (i > 0))
+		{ val = fromhex (c) * 16 + fromhex (*(p+1));
 		  *myaddr++ = val;
+		  if (remote_debug) printf("[%02x]",val) ;
 		  --i;
+		  fetched++ ;
 		}
 	      ++dumpaddr;
 	      ++p;
 	    }
-	  ++p;
+	  ++p; /* skip a blank or other non hex char */
+	  c = *p ;
 	}
-      return len;
+      if (fetched == 0) error("Failed to read via monitor") ;
+      if (remote_debug) printf("\n") ;
+      return fetched ; /* Return the number of bytes actually read */
     }
+  RDEBUG(("MON scanning bytes\n")) ;
 
   for (i = len; i > 0; i--)
     {
@@ -1425,6 +1826,16 @@ monitor_read_memory (memaddr, myaddr, len)
   return len;
 }
 
+/* This version supports very large reads by looping on multiline
+   dump bytes outputs. Beware of buffering limits.
+   */
+static int monotor_read_memory_block(memaddr,myaddr,len)
+     CORE_ADDR memaddr ;
+     char * myaddr ;
+     int len ;
+{
+}
+
 static int
 monitor_xfer_memory (memaddr, myaddr, len, write, target)
      CORE_ADDR memaddr;
@@ -1486,6 +1897,7 @@ monitor_insert_breakpoint (addr, shadow)
   unsigned char *bp;
   int bplen;
 
+  RDEBUG(("MON inst bkpt %08x\n",addr)) 
   if (current_monitor->set_break == NULL)
     error ("No set_break defined for this monitor");
 
@@ -1519,6 +1931,7 @@ monitor_remove_breakpoint (addr, shadow)
 {
   int i;
 
+  RDEBUG(("MON rmbkpt %08x\n",addr))
   if (current_monitor->clr_break == NULL)
     error ("No clr_break defined for this monitor");
 
@@ -1580,6 +1993,7 @@ monitor_load (file, from_tty)
     int  from_tty;
 {
   dcache_flush (remote_dcache);
+  RDEBUG(("MON load\n"))
 
   if (current_monitor->load_routine)
     current_monitor->load_routine (monitor_desc, file, hashmark);
@@ -1627,6 +2041,7 @@ monitor_load (file, from_tty)
 static void
 monitor_stop ()
 {
+  RDEBUG(("MON stop\n")) ;
   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
     SERIAL_SEND_BREAK (monitor_desc);
   if (current_monitor->stop)