gdb/remote-array.c

   1 /* Remote debugging interface for Array Tech RAID controller..
   2    Copyright 90, 91, 92, 93, 94, 1995  Free Software Foundation, Inc.
   3    Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
   4
   5    This module talks to a debug monitor called 'MONITOR', which
   6    We communicate with MONITOR via either a direct serial line, or a TCP
   7    (or possibly TELNET) stream to a terminal multiplexor,
   8    which in turn talks to the target board.
   9
  10   This file is part of GDB.
  11
  12   This program is free software; you can redistribute it and/or modify
  13   it under the terms of the GNU General Public License as published by
  14   the Free Software Foundation; either version 2 of the License, or
  15   (at your option) any later version.
  16
  17   This program is distributed in the hope that it will be useful,
  18   but WITHOUT ANY WARRANTY; without even the implied warranty of
  19   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20   GNU General Public License for more details.
  21
  22   You should have received a copy of the GNU General Public License
  23   along with this program; if not, write to the Free Software
  24   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25  */
  26
  27 #include "defs.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "wait.h"
  31 #ifdef ANSI_PROTOTYPES
  32 #include <stdarg.h>
  33 #else
  34 #include <varargs.h>
  35 #endif
  36 #include <signal.h>
  37 #include "gdb_string.h"
  38 #include <sys/types.h>
  39 #include "command.h"
  40 #include "serial.h"
  41 #include "monitor.h"
  42 #include "remote-utils.h"
  43
  44 extern int baud_rate;
  45
  46 static const char hexchars[]="0123456789abcdef";
  47 static char *hex2mem();
  48
  49 #define SREC_SIZE 160
  50
  51 #define SWAP_TARGET_AND_HOST(buffer,len)                                \
  52   do                                                                    \
  53     {                                                                   \
  54       if (TARGET_BYTE_ORDER != HOST_BYTE_ORDER)                         \
  55         {                                                               \
  56           char tmp;                                                     \
  57           char *p = (char *)(buffer);                                   \
  58           char *q = ((char *)(buffer)) + len - 1;                       \
  59           for (; p < q; p++, q--)                                       \
  60             {                                                           \
  61               tmp = *q;                                                 \
  62               *q = *p;                                                  \
  63               *p = tmp;                                                 \
  64             }                                                           \
  65         }                                                               \
  66     }                                                                   \
  67   while (0)
  68
  69 static void debuglogs PARAMS((int, char *, ...));
  70 static void array_open();
  71 static void array_close();
  72 static void array_detach();
  73 static void array_attach();
  74 static void array_resume();
  75 static void array_fetch_register();
  76 static void array_store_register();
  77 static void array_fetch_registers();
  78 static void array_store_registers();
  79 static void array_prepare_to_store();
  80 static void array_files_info();
  81 static void array_kill();
  82 static void array_create_inferior();
  83 static void array_mourn_inferior();
  84 static void make_gdb_packet();
  85 static int array_xfer_memory();
  86 static int array_wait();
  87 static int array_insert_breakpoint();
  88 static int array_remove_breakpoint();
  89 static int tohex();
  90 static int to_hex();
  91 static int from_hex();
  92 static int array_send_packet();
  93 static int array_get_packet();
  94 static unsigned long ascii2hexword();
  95 static char *hexword2ascii();
  96
  97 extern char *version;
  98
  99 #define LOG_FILE "monitor.log"
 100 #if defined (LOG_FILE)
 101 FILE *log_file;
 102 #endif
 103
 104 static int timeout = 30;
 105 /* Having this larger than 400 causes us to be incompatible with m68k-stub.c
 106    and i386-stub.c.  Normally, no one would notice because it only matters
 107    for writing large chunks of memory (e.g. in downloads).  Also, this needs
 108    to be more than 400 if required to hold the registers (see below, where
 109    we round it up based on REGISTER_BYTES).  */
 110 #define PBUFSIZ 400
 111
 112 /*
 113  * Descriptor for I/O to remote machine.  Initialize it to NULL so that
 114  * array_open knows that we don't have a file open when the program starts.
 115  */
 116 serial_t array_desc = NULL;
 117
 118 /*
 119  * this array of registers need to match the indexes used by GDB. The
 120  * whole reason this exists is cause the various ROM monitors use
 121  * different strings than GDB does, and doesn't support all the
 122  * registers either. So, typing "info reg sp" becomes a "r30".
 123  */
 124 extern char *tmp_mips_processor_type;
 125 extern int mips_set_processor_type();
 126
 127 static struct target_ops array_ops = {
 128   "array",                      /* to_shortname */
 129                                 /* to_longname */
 130   "Debug using the standard GDB remote protocol for the Array Tech target.",
 131                                 /* to_doc */
 132   "Debug using the standard GDB remote protocol for the Array Tech target.\n\
 133 Specify the serial device it is connected to (e.g. /dev/ttya).",
 134   array_open,                   /* to_open */
 135   array_close,                  /* to_close */
 136   NULL,                         /* to_attach */
 137   array_detach,                 /* to_detach */
 138   array_resume,                 /* to_resume */
 139   array_wait,                   /* to_wait */
 140   array_fetch_registers,        /* to_fetch_registers */
 141   array_store_registers,        /* to_store_registers */
 142   array_prepare_to_store,       /* to_prepare_to_store */
 143   array_xfer_memory,            /* to_xfer_memory */
 144   array_files_info,             /* to_files_info */
 145   array_insert_breakpoint,      /* to_insert_breakpoint */
 146   array_remove_breakpoint,      /* to_remove_breakpoint */
 147   0,                            /* to_terminal_init */
 148   0,                            /* to_terminal_inferior */
 149   0,                            /* to_terminal_ours_for_output */
 150   0,                            /* to_terminal_ours */
 151   0,                            /* to_terminal_info */
 152   array_kill,                   /* to_kill */
 153   0,                            /* to_load */
 154   0,                            /* to_lookup_symbol */
 155   array_create_inferior,        /* to_create_inferior */
 156   array_mourn_inferior,         /* to_mourn_inferior */
 157   0,                            /* to_can_run */
 158   0,                            /* to_notice_signals */
 159   0,                            /* to_thread_alive */
 160   0,                            /* to_stop */
 161   process_stratum,              /* to_stratum */
 162   0,                            /* to_next */
 163   1,                            /* to_has_all_memory */
 164   1,                            /* to_has_memory */
 165   1,                            /* to_has_stack */
 166   1,                            /* to_has_registers */
 167   1,                            /* to_has_execution */
 168   0,                            /* sections */
 169   0,                            /* sections_end */
 170   OPS_MAGIC                     /* to_magic */
 171 };
 172
 173 /*
 174  * printf_monitor -- send data to monitor.  Works just like printf.
 175  */
 176 static void
 177 #ifdef ANSI_PROTOTYPES
 178 printf_monitor(char *pattern, ...)
 179 #else
 180 printf_monitor(va_alist)
 181      va_dcl
 182 #endif
 183 {
 184   va_list args;
 185   char buf[PBUFSIZ];
 186   int i;
 187
 188 #ifdef ANSI_PROTOTYPES
 189   va_start(args, pattern);
 190 #else
 191   char *pattern;
 192   va_start(args);
 193   pattern = va_arg(args, char *);
 194 #endif
 195
 196   vsprintf(buf, pattern, args);
 197
 198   debuglogs (1, "printf_monitor(), Sending: \"%s\".", buf);
 199
 200   if (strlen(buf) > PBUFSIZ)
 201     error ("printf_monitor(): string too long");
 202   if (SERIAL_WRITE(array_desc, buf, strlen(buf)))
 203     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
 204 }
 205 /*
 206  * write_monitor -- send raw data to monitor.
 207  */
 208 static void
 209 write_monitor(data, len)
 210      char data[];
 211      int len;
 212 {
 213   if (SERIAL_WRITE(array_desc, data, len))
 214     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
 215
 216   *(data + len+1) = '\0';
 217   debuglogs (1, "write_monitor(), Sending: \"%s\".", data);
 218
 219 }
 220
 221 /*
 222  * debuglogs -- deal with debugging info to multiple sources. This takes
 223  *      two real args, the first one is the level to be compared against
 224  *      the sr_get_debug() value, the second arg is a printf buffer and args
 225  *      to be formatted and printed. A CR is added after each string is printed.
 226  */
 227 static void
 228 #ifdef ANSI_PROTOTYPES
 229 debuglogs(int level, char *pattern, ...)
 230 #else
 231 debuglogs(va_alist)
 232      va_dcl
 233 #endif
 234 {
 235   va_list args;
 236   char *p;
 237   unsigned char buf[PBUFSIZ];
 238   char newbuf[PBUFSIZ];
 239   int i;
 240
 241 #ifdef ANSI_PROTOTYPES
 242   va_start(args, pattern);
 243 #else
 244   char *pattern;
 245   int level;
 246   va_start(args);
 247   level = va_arg(args, int);                    /* get the debug level */
 248   pattern = va_arg(args, char *);               /* get the printf style pattern */
 249 #endif
 250
 251   if ((level <0) || (level > 100)) {
 252     error ("Bad argument passed to debuglogs(), needs debug level");
 253     return;
 254   }
 255
 256   vsprintf(buf, pattern, args);                 /* format the string */
 257
 258   /* convert some characters so it'll look right in the log */
 259   p = newbuf;
 260   for (i = 0 ; buf[i] != '\0'; i++) {
 261     if (i > PBUFSIZ)
 262       error ("Debug message too long");
 263     switch (buf[i]) {
 264     case '\n':                                  /* newlines */
 265       *p++ = '\\';
 266       *p++ = 'n';
 267       continue;
 268     case '\r':                                  /* carriage returns */
 269       *p++ = '\\';
 270       *p++ = 'r';
 271       continue;
 272     case '\033':                                /* escape */
 273       *p++ = '\\';
 274       *p++ = 'e';
 275       continue;
 276     case '\t':                                  /* tab */
 277       *p++ = '\\';
 278       *p++ = 't';
 279       continue;
 280     case '\b':                                  /* backspace */
 281       *p++ = '\\';
 282       *p++ = 'b';
 283       continue;
 284     default:                                    /* no change */
 285       *p++ = buf[i];
 286     }
 287
 288     if (buf[i] < 26) {                          /* modify control characters */
 289       *p++ = '^';
 290       *p++ = buf[i] + 'A';
 291       continue;
 292     }
 293      if (buf[i] >= 128) {                       /* modify control characters */
 294       *p++ = '!';
 295       *p++ = buf[i] + 'A';
 296       continue;
 297     }
 298  }
 299   *p = '\0';                                    /* terminate the string */
 300
 301   if (sr_get_debug() > level)
 302     printf_unfiltered ("%s\n", newbuf);
 303
 304 #ifdef LOG_FILE                                 /* write to the monitor log */
 305   if (log_file != 0x0) {
 306     fputs (newbuf, log_file);
 307     fputc ('\n', log_file);
 308     fflush (log_file);
 309   }
 310 #endif
 311 }
 312
 313 /* readchar -- read a character from the remote system, doing all the fancy
 314  *      timeout stuff.
 315  */
 316 static int
 317 readchar(timeout)
 318      int timeout;
 319 {
 320   int c;
 321
 322   c = SERIAL_READCHAR(array_desc, abs(timeout));
 323
 324   if (sr_get_debug() > 5) {
 325     putchar(c & 0x7f);
 326     debuglogs (5, "readchar: timeout = %d\n", timeout);
 327   }
 328
 329 #ifdef LOG_FILE
 330   if (isascii (c))
 331     putc(c & 0x7f, log_file);
 332 #endif
 333
 334   if (c >= 0)
 335     return c & 0x7f;
 336
 337   if (c == SERIAL_TIMEOUT) {
 338     if (timeout <= 0)
 339       return c;         /* Polls shouldn't generate timeout errors */
 340     error("Timeout reading from remote system.");
 341 #ifdef LOG_FILE
 342       fputs ("ERROR: Timeout reading from remote system", log_file);
 343 #endif
 344   }
 345   perror_with_name("readchar");
 346 }
 347
 348 /*
 349  * expect --  scan input from the remote system, until STRING is found.
 350  *      If DISCARD is non-zero, then discard non-matching input, else print
 351  *      it out. Let the user break out immediately.
 352  */
 353 static void
 354 expect (string, discard)
 355      char *string;
 356      int discard;
 357 {
 358   char *p = string;
 359   int c;
 360
 361
 362   debuglogs (1, "Expecting \"%s\".", string);
 363
 364   immediate_quit = 1;
 365   while (1) {
 366     c = readchar(timeout);
 367     if (!isascii (c))
 368       continue;
 369     if (c == *p++) {
 370       if (*p == '\0') {
 371         immediate_quit = 0;
 372         debuglogs (4, "Matched");
 373         return;
 374       }
 375     } else {
 376       if (!discard) {
 377         fputc_unfiltered (c, gdb_stdout);
 378       }
 379       p = string;
 380     }
 381   }
 382 }
 383
 384 /* Keep discarding input until we see the MONITOR array_cmds->prompt.
 385
 386    The convention for dealing with the expect_prompt is that you
 387    o give your command
 388    o *then* wait for the expect_prompt.
 389
 390    Thus the last thing that a procedure does with the serial line
 391    will be an expect_prompt().  Exception:  array_resume does not
 392    wait for the expect_prompt, because the terminal is being handed over
 393    to the inferior.  However, the next thing which happens after that
 394    is a array_wait which does wait for the expect_prompt.
 395    Note that this includes abnormal exit, e.g. error().  This is
 396    necessary to prevent getting into states from which we can't
 397    recover.  */
 398 static void
 399 expect_prompt(discard)
 400      int discard;
 401 {
 402   expect (expect_prompt, discard);
 403 }
 404
 405 /*
 406  * junk -- ignore junk characters. Returns a 1 if junk, 0 otherwise
 407  */
 408 static int
 409 junk(ch)
 410      char ch;
 411 {
 412   switch (ch) {
 413   case '\0':
 414   case ' ':
 415   case '-':
 416   case '\t':
 417   case '\r':
 418   case '\n':
 419     if (sr_get_debug() > 5)
 420       debuglogs (5, "Ignoring \'%c\'.", ch);
 421     return 1;
 422   default:
 423     if (sr_get_debug() > 5)
 424       debuglogs (5, "Accepting \'%c\'.", ch);
 425     return 0;
 426   }
 427 }
 428
 429 /*
 430  *  get_hex_digit -- Get a hex digit from the remote system & return its value.
 431  *              If ignore is nonzero, ignore spaces, newline & tabs.
 432  */
 433 static int
 434 get_hex_digit(ignore)
 435      int ignore;
 436 {
 437   static int ch;
 438   while (1) {
 439     ch = readchar(timeout);
 440     if (junk(ch))
 441       continue;
 442     if (sr_get_debug() > 4) {
 443       debuglogs (4, "get_hex_digit() got a 0x%x(%c)", ch, ch);
 444     } else {
 445 #ifdef LOG_FILE                                 /* write to the monitor log */
 446       if (log_file != 0x0) {
 447         fputs ("get_hex_digit() got a 0x", log_file);
 448         fputc (ch, log_file);
 449         fputc ('\n', log_file);
 450         fflush (log_file);
 451       }
 452 #endif
 453     }
 454
 455     if (ch >= '0' && ch <= '9')
 456       return ch - '0';
 457     else if (ch >= 'A' && ch <= 'F')
 458       return ch - 'A' + 10;
 459     else if (ch >= 'a' && ch <= 'f')
 460       return ch - 'a' + 10;
 461     else if (ch == ' ' && ignore)
 462       ;
 463     else {
 464      expect_prompt(1);
 465       debuglogs (4, "Invalid hex digit from remote system. (0x%x)", ch);
 466       error("Invalid hex digit from remote system. (0x%x)", ch);
 467     }
 468   }
 469 }
 470
 471 /* get_hex_byte -- Get a byte from monitor and put it in *BYT.
 472  *      Accept any number leading spaces.
 473  */
 474 static void
 475 get_hex_byte (byt)
 476      char *byt;
 477 {
 478   int val;
 479
 480   val = get_hex_digit (1) << 4;
 481   debuglogs (4, "get_hex_byte() -- Read first nibble 0x%x", val);
 482
 483   val |= get_hex_digit (0);
 484   debuglogs (4, "get_hex_byte() -- Read second nibble 0x%x", val);
 485   *byt = val;
 486
 487   debuglogs (4, "get_hex_byte() -- Read a 0x%x", val);
 488 }
 489
 490 /*
 491  * get_hex_word --  Get N 32-bit words from remote, each preceded by a space,
 492  *      and put them in registers starting at REGNO.
 493  */
 494 static int
 495 get_hex_word ()
 496 {
 497   long val, newval;
 498   int i;
 499
 500   val = 0;
 501
 502 #if 0
 503   if (HOST_BYTE_ORDER == BIG_ENDIAN) {
 504 #endif
 505     for (i = 0; i < 8; i++)
 506       val = (val << 4) + get_hex_digit (i == 0);
 507 #if 0
 508   } else {
 509     for (i = 7; i >= 0; i--)
 510       val = (val << 4) + get_hex_digit (i == 0);
 511   }
 512 #endif
 513
 514   debuglogs (4, "get_hex_word() got a 0x%x for a %s host.", val, (HOST_BYTE_ORDER == BIG_ENDIAN) ? "big endian" : "little endian");
 515
 516   return val;
 517 }
 518
 519 /* This is called not only when we first attach, but also when the
 520    user types "run" after having attached.  */
 521 static void
 522 array_create_inferior (execfile, args, env)
 523      char *execfile;
 524      char *args;
 525      char **env;
 526 {
 527   int entry_pt;
 528
 529   if (args && *args)
 530     error("Can't pass arguments to remote MONITOR process");
 531
 532   if (execfile == 0 || exec_bfd == 0)
 533     error("No exec file specified");
 534
 535   entry_pt = (int) bfd_get_start_address (exec_bfd);
 536
 537 /* The "process" (board) is already stopped awaiting our commands, and
 538    the program is already downloaded.  We just set its PC and go.  */
 539
 540   clear_proceed_status ();
 541
 542   /* Tell wait_for_inferior that we've started a new process.  */
 543   init_wait_for_inferior ();
 544
 545   /* Set up the "saved terminal modes" of the inferior
 546      based on what modes we are starting it with.  */
 547   target_terminal_init ();
 548
 549   /* Install inferior's terminal modes.  */
 550   target_terminal_inferior ();
 551
 552   /* insert_step_breakpoint ();  FIXME, do we need this?  */
 553
 554   /* Let 'er rip... */
 555   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 556 }
 557
 558 /*
 559  * array_open -- open a connection to a remote debugger.
 560  *      NAME is the filename used for communication.
 561  */
 562 static int baudrate = 9600;
 563 static char dev_name[100];
 564
 565 static void
 566 array_open(args, name, from_tty)
 567      char *args;
 568      char *name;
 569      int from_tty;
 570 {
 571   char packet[PBUFSIZ];
 572
 573   if (args == NULL)
 574     error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
 575 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
 576
 577 /*  if (is_open) */
 578     array_close(0);
 579
 580   tmp_mips_processor_type = "lsi33k";   /* change the default from r3051 */
 581   mips_set_processor_type_command ("lsi33k", 0);
 582
 583   strcpy(dev_name, args);
 584   array_desc = SERIAL_OPEN(dev_name);
 585
 586   if (array_desc == NULL)
 587     perror_with_name(dev_name);
 588
 589   if (baud_rate != -1) {
 590     if (SERIAL_SETBAUDRATE (array_desc, baud_rate)) {
 591       SERIAL_CLOSE (array_desc);
 592       perror_with_name (name);
 593     }
 594   }
 595
 596   SERIAL_RAW(array_desc);
 597
 598 #if defined (LOG_FILE)
 599   log_file = fopen (LOG_FILE, "w");
 600   if (log_file == NULL)
 601     perror_with_name (LOG_FILE);
 602   fprintf_filtered (log_file, "GDB %s (%s", version);
 603   fprintf_filtered (log_file, " --target %s)\n", array_ops.to_shortname);
 604   fprintf_filtered (log_file, "Remote target %s connected to %s\n\n", array_ops.to_shortname, dev_name);
 605 #endif
 606
 607   /* see if the target is alive. For a ROM monitor, we can just try to force the
 608      expect_prompt to print a few times. For the GDB remote protocol, the application
 609      being debugged is sitting at a breakpoint and waiting for GDB to initialize
 610      the connection. We force it to give us an empty packet to see if it's alive.
 611      */
 612     debuglogs (3, "Trying to ACK the target's debug stub");
 613     /* unless your are on the new hardware, the old board won't initialize
 614        because the '+' doesn't flush output like it does on the new ROMS.
 615      */
 616     printf_monitor ("+");       /* ask for the last signal */
 617     expect_prompt(1);           /* See if we get a expect_prompt */
 618     make_gdb_packet (packet, "?");      /* ask for a bogus packet */
 619     if (array_send_packet (packet) == 0)
 620       error ("Couldn't transmit packet\n");
 621     printf_monitor ("+\n");     /* force it to flush stdout */
 622    expect_prompt(1);            /* See if we get a expect_prompt */
 623
 624   if (from_tty)
 625     printf("Remote target %s connected to %s\n", array_ops.to_shortname, dev_name);
 626 }
 627
 628 /*
 629  * array_close -- Close out all files and local state before this
 630  *      target loses control.
 631  */
 632
 633 static void
 634 array_close (quitting)
 635      int quitting;
 636 {
 637   SERIAL_CLOSE(array_desc);
 638   array_desc = NULL;
 639
 640   debuglogs (1, "array_close (quitting=%d)", quitting);
 641
 642 #if defined (LOG_FILE)
 643   if (log_file) {
 644     if (ferror(log_file))
 645       printf_filtered ("Error writing log file.\n");
 646     if (fclose(log_file) != 0)
 647       printf_filtered ("Error closing log file.\n");
 648   }
 649 #endif
 650 }
 651
 652 /*
 653  * array_detach -- terminate the open connection to the remote
 654  *      debugger. Use this when you want to detach and do something
 655  *      else with your gdb.
 656  */
 657 static void
 658 array_detach (from_tty)
 659      int from_tty;
 660 {
 661
 662   debuglogs (1, "array_detach ()");
 663
 664   pop_target();         /* calls array_close to do the real work */
 665   if (from_tty)
 666     printf ("Ending remote %s debugging\n", target_shortname);
 667 }
 668
 669 /*
 670  * array_attach -- attach GDB to the target.
 671  */
 672 static void
 673 array_attach (args, from_tty)
 674      char *args;
 675      int from_tty;
 676 {
 677   if (from_tty)
 678     printf ("Starting remote %s debugging\n", target_shortname);
 679
 680   debuglogs (1, "array_attach (args=%s)", args);
 681
 682   printf_monitor ("go %x\n");
 683   /* swallow the echo.  */
 684   expect ("go %x\n", 1);
 685 }
 686
 687 /*
 688  * array_resume -- Tell the remote machine to resume.
 689  */
 690 static void
 691 array_resume (pid, step, sig)
 692      int pid, step;
 693      enum target_signal sig;
 694 {
 695   debuglogs (1, "array_resume (step=%d, sig=%d)", step, sig);
 696
 697   if (step) {
 698     printf_monitor ("s\n");
 699   } else {
 700     printf_monitor ("go");
 701   }
 702 }
 703
 704 /*
 705  * array_wait -- Wait until the remote machine stops, then return,
 706  *          storing status in status just as `wait' would.
 707  */
 708 static int
 709 array_wait (pid, status)
 710      int pid;
 711      struct target_waitstatus *status;
 712 {
 713   int old_timeout = timeout;
 714
 715   debuglogs(1, "array_wait (), printing extraneous text.");
 716
 717   status->kind = TARGET_WAITKIND_EXITED;
 718   status->value.integer = 0;
 719
 720   timeout = 0;          /* Don't time out -- user program is running. */
 721
 722  expect_prompt(0);    /* Wait for expect_prompt, outputting extraneous text */
 723   debuglogs (4, "array_wait(), got the expect_prompt.");
 724
 725   status->kind = TARGET_WAITKIND_STOPPED;
 726   status->value.sig = TARGET_SIGNAL_TRAP;
 727
 728
 729
 730   timeout = old_timeout;
 731
 732   return 0;
 733 }
 734
 735 /*
 736  * array_fetch_registers -- read the remote registers into the
 737  *      block regs.
 738  */
 739 static void
 740 array_fetch_registers (ignored)
 741      int ignored;
 742 {
 743   int regno, i;
 744   char *p;
 745   unsigned char packet[PBUFSIZ];
 746   char regs[REGISTER_BYTES];
 747
 748   debuglogs (1, "array_fetch_registers (ignored=%d)\n", ignored);
 749
 750   memset (packet, 0, PBUFSIZ);
 751   /* Unimplemented registers read as all bits zero.  */
 752   memset (regs, 0, REGISTER_BYTES);
 753   make_gdb_packet (packet, "g");
 754   if (array_send_packet (packet) == 0)
 755     error ("Couldn't transmit packet\n");
 756   if (array_get_packet (packet) == 0)
 757     error ("Couldn't receive packet\n");
 758   /* FIXME: read bytes from packet */
 759   debuglogs (4, "array_fetch_registers: Got a \"%s\" back\n", packet);
 760   for (regno = 0; regno <= PC_REGNUM+4; regno++) {
 761     /* supply register stores in target byte order, so swap here */
 762     /* FIXME: convert from ASCII hex to raw bytes */
 763     i = ascii2hexword (packet + (regno * 8));
 764     debuglogs (5, "Adding register %d = %x\n", regno, i);
 765     SWAP_TARGET_AND_HOST (&i, 4);
 766     supply_register (regno, (char *)&i);
 767   }
 768 }
 769
 770 /*
 771  * This is unused by targets like this one that use a
 772  * protocol based on GDB's remote protocol.
 773  */
 774 static void
 775 array_fetch_register (ignored)
 776      int ignored;
 777 {
 778   array_fetch_registers ();
 779 }
 780
 781 /*
 782  * Get all the registers from the targets. They come back in a large array.
 783  */
 784 static void
 785 array_store_registers (ignored)
 786      int ignored;
 787 {
 788   int regno;
 789   unsigned long i;
 790   char packet[PBUFSIZ];
 791   char buf[PBUFSIZ];
 792   char num[9];
 793
 794   debuglogs (1, "array_store_registers()");
 795
 796   memset (packet, 0, PBUFSIZ);
 797   memset (buf, 0, PBUFSIZ);
 798   buf[0] = 'G';
 799
 800   /* Unimplemented registers read as all bits zero.  */
 801   /* FIXME: read bytes from packet */
 802   for (regno = 0; regno < 41; regno++) { /* FIXME */
 803     /* supply register stores in target byte order, so swap here */
 804     /* FIXME: convert from ASCII hex to raw bytes */
 805     i = (unsigned long)read_register (regno);
 806     hexword2ascii (num, i);
 807     strcpy (buf+(regno * 8)+1, num);
 808   }
 809   *(buf + (regno * 8) + 2) = 0;
 810   make_gdb_packet (packet, buf);
 811   if (array_send_packet (packet) == 0)
 812     error ("Couldn't transmit packet\n");
 813   if (array_get_packet (packet) == 0)
 814     error ("Couldn't receive packet\n");
 815
 816   registers_changed ();
 817 }
 818
 819 /*
 820  * This is unused by targets like this one that use a
 821  * protocol based on GDB's remote protocol.
 822  */
 823 static void
 824 array_store_register (ignored)
 825      int ignored;
 826 {
 827   array_store_registers ();
 828 }
 829
 830 /* Get ready to modify the registers array.  On machines which store
 831    individual registers, this doesn't need to do anything.  On machines
 832    which store all the registers in one fell swoop, this makes sure
 833    that registers contains all the registers from the program being
 834    debugged.  */
 835
 836 static void
 837 array_prepare_to_store ()
 838 {
 839   /* Do nothing, since we can store individual regs */
 840 }
 841
 842 static void
 843 array_files_info ()
 844 {
 845   printf ("\tAttached to %s at %d baud.\n",
 846           dev_name, baudrate);
 847 }
 848
 849 /*
 850  * array_write_inferior_memory -- Copy LEN bytes of data from debugger
 851  *      memory at MYADDR to inferior's memory at MEMADDR.  Returns length moved.
 852  */
 853 static int
 854 array_write_inferior_memory (memaddr, myaddr, len)
 855      CORE_ADDR memaddr;
 856      unsigned char *myaddr;
 857      int len;
 858 {
 859   unsigned long i;
 860   int j;
 861   char packet[PBUFSIZ];
 862   char buf[PBUFSIZ];
 863   char num[9];
 864   char *p;
 865
 866   debuglogs (1, "array_write_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len);
 867   memset (buf, '\0', PBUFSIZ);          /* this also sets the string terminator */
 868   p = buf;
 869
 870   *p++ = 'M';                           /* The command to write memory */
 871   hexword2ascii (num, memaddr); /* convert the address */
 872   strcpy (p, num);                      /* copy the address */
 873   p += 8;
 874   *p++ = ',';                           /* add comma delimeter */
 875   hexword2ascii (num, len);             /* Get the length as a 4 digit number */
 876   *p++ = num[4];
 877   *p++ = num[5];
 878   *p++ = num[6];
 879   *p++ = num[7];
 880   *p++ = ':';                           /* add the colon delimeter */
 881   for (j = 0; j < len; j++) {           /* copy the data in after converting it */
 882     *p++ = tohex ((myaddr[j] >> 4) & 0xf);
 883     *p++ = tohex  (myaddr[j] & 0xf);
 884   }
 885
 886   make_gdb_packet (packet, buf);
 887   if (array_send_packet (packet) == 0)
 888     error ("Couldn't transmit packet\n");
 889   if (array_get_packet (packet) == 0)
 890     error ("Couldn't receive packet\n");
 891
 892   return len;
 893 }
 894
 895 /*
 896  * array_read_inferior_memory -- read LEN bytes from inferior memory
 897  *      at MEMADDR.  Put the result at debugger address MYADDR.  Returns
 898  *      length moved.
 899  */
 900 static int
 901 array_read_inferior_memory(memaddr, myaddr, len)
 902      CORE_ADDR memaddr;
 903      char *myaddr;
 904      int len;
 905 {
 906   int i, j;
 907   char buf[20];
 908   char packet[PBUFSIZ];
 909
 910   /* Number of bytes read so far.  */
 911   int count;
 912
 913   /* Starting address of this pass.  */
 914   unsigned long startaddr;
 915
 916   /* Starting address of this pass.  */
 917   unsigned long endaddr;
 918
 919   /* Number of bytes to read in this pass.  */
 920   int len_this_pass;
 921
 922   debuglogs (1, "array_read_inferior_memory (memaddr=0x%x, myaddr=0x%x, len=%d)", memaddr, myaddr, len);
 923
 924   /* Note that this code works correctly if startaddr is just less
 925      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 926      thing).  That is, something like
 927      array_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 928      works--it never adds len To memaddr and gets 0.  */
 929   /* However, something like
 930      array_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 931      doesn't need to work.  Detect it and give up if there's an attempt
 932      to do that.  */
 933   if (((memaddr - 1) + len) < memaddr) {
 934     errno = EIO;
 935     return 0;
 936   }
 937
 938   startaddr = memaddr;
 939   count = 0;
 940   while (count < len) {
 941     len_this_pass = 16;
 942     if ((startaddr % 16) != 0)
 943       len_this_pass -= startaddr % 16;
 944     if (len_this_pass > (len - count))
 945       len_this_pass = (len - count);
 946
 947     debuglogs (3, "Display %d bytes at %x for Big Endian host", len_this_pass, startaddr);
 948
 949     for (i = 0; i < len_this_pass; i++) {
 950       sprintf (buf, "m%08x,%04x", startaddr, len_this_pass);
 951       make_gdb_packet (packet, buf);
 952       if (array_send_packet (packet) == 0)
 953         error ("Couldn't transmit packet\n");
 954       if (array_get_packet (packet) == 0)
 955         error ("Couldn't receive packet\n");
 956       if (*packet == 0)
 957         error ("Got no data in the GDB packet\n");
 958       debuglogs (4, "array_read_inferior: Got a \"%s\" back\n", packet);
 959       for (j = 0; j < len_this_pass ; j++) {            /* extract the byte values */
 960         myaddr[count++] = from_hex (*(packet+(j*2))) * 16 + from_hex (*(packet+(j*2)+1));
 961         debuglogs (5, "myaddr set to %x\n", myaddr[count-1]);
 962       }
 963       startaddr += 1;
 964     }
 965
 966   }
 967   return len;
 968 }
 969
 970 /* FIXME-someday!  merge these two.  */
 971 static int
 972 array_xfer_memory (memaddr, myaddr, len, write, target)
 973      CORE_ADDR memaddr;
 974      char *myaddr;
 975      int len;
 976      int write;
 977      struct target_ops *target;         /* ignored */
 978 {
 979   if (write)
 980     return array_write_inferior_memory (memaddr, myaddr, len);
 981   else
 982     return array_read_inferior_memory (memaddr, myaddr, len);
 983 }
 984
 985 static void
 986 array_kill (args, from_tty)
 987      char *args;
 988      int from_tty;
 989 {
 990   return;               /* ignore attempts to kill target system */
 991 }
 992
 993 /* Clean up when a program exits.
 994    The program actually lives on in the remote processor's RAM, and may be
 995    run again without a download.  Don't leave it full of breakpoint
 996    instructions.  */
 997
 998 static void
 999 array_mourn_inferior ()
1000 {
1001   remove_breakpoints ();
1002   generic_mourn_inferior ();    /* Do all the proper things now */
1003 }
1004
1005 #define MAX_ARRAY_BREAKPOINTS 16
1006
1007 extern int memory_breakpoint_size;
1008 static CORE_ADDR breakaddr[MAX_ARRAY_BREAKPOINTS] = {0};
1009
1010 /*
1011  * array_insert_breakpoint -- add a breakpoint
1012  */
1013 static int
1014 array_insert_breakpoint (addr, shadow)
1015      CORE_ADDR addr;
1016      char *shadow;
1017 {
1018   int i;
1019
1020   debuglogs (1, "array_insert_breakpoint() addr = 0x%x", addr);
1021
1022   for (i = 0; i <= MAX_ARRAY_BREAKPOINTS; i++) {
1023     if (breakaddr[i] == 0) {
1024       breakaddr[i] = addr;
1025       if (sr_get_debug() > 4)
1026         printf ("Breakpoint at %x\n", addr);
1027       array_read_inferior_memory(addr, shadow, memory_breakpoint_size);
1028       printf_monitor("brk 0x%x\n", addr);
1029      expect_prompt(1);
1030       return 0;
1031     }
1032   }
1033
1034   fprintf(stderr, "Too many breakpoints (> 16) for monitor\n");
1035   return 1;
1036 }
1037
1038 /*
1039  * _remove_breakpoint -- Tell the monitor to remove a breakpoint
1040  */
1041 static int
1042 array_remove_breakpoint (addr, shadow)
1043      CORE_ADDR addr;
1044      char *shadow;
1045 {
1046   int i;
1047
1048   debuglogs (1, "array_remove_breakpoint() addr = 0x%x", addr);
1049
1050   for (i = 0; i < MAX_ARRAY_BREAKPOINTS; i++) {
1051     if (breakaddr[i] == addr) {
1052       breakaddr[i] = 0;
1053       /* some monitors remove breakpoints based on the address */
1054       printf_monitor("unbrk %x\n", i);
1055      expect_prompt(1);
1056       return 0;
1057     }
1058   }
1059   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
1060   return 1;
1061 }
1062
1063 static void
1064 array_stop ()
1065 {
1066   debuglogs (1, "array_stop()");
1067   printf_monitor("\003");
1068  expect_prompt(1);
1069 }
1070
1071 /*
1072  * array_command -- put a command string, in args, out to MONITOR.
1073  *      Output from MONITOR is placed on the users terminal until the
1074  *      expect_prompt is seen. FIXME
1075  */
1076 static void
1077 monitor_command (args, fromtty)
1078      char       *args;
1079      int        fromtty;
1080 {
1081   debuglogs (1, "monitor_command (args=%s)", args);
1082
1083   if (array_desc == NULL)
1084     error("monitor target not open.");
1085
1086   if (!args)
1087     error("Missing command.");
1088
1089   printf_monitor ("%s\n", args);
1090   expect_prompt(0);
1091 }
1092
1093 /*
1094  * make_gdb_packet -- make a GDB packet. The data is always ASCII.
1095  *       A debug packet whose contents are <data>
1096  *       is encapsulated for transmission in the form:
1097  *
1098  *              $ <data> # CSUM1 CSUM2
1099  *
1100  *       <data> must be ASCII alphanumeric and cannot include characters
1101  *       '$' or '#'.  If <data> starts with two characters followed by
1102  *       ':', then the existing stubs interpret this as a sequence number.
1103  *
1104  *       CSUM1 and CSUM2 are ascii hex representation of an 8-bit
1105  *       checksum of <data>, the most significant nibble is sent first.
1106  *       the hex digits 0-9,a-f are used.
1107  *
1108  */
1109 static void
1110 make_gdb_packet (buf, data)
1111      char *buf, *data;
1112 {
1113   int i;
1114   unsigned char csum = 0;
1115   int cnt;
1116   char *p;
1117
1118   debuglogs (3, "make_gdb_packet(%s)\n", data);
1119   cnt  = strlen (data);
1120   if (cnt > PBUFSIZ)
1121     error ("make_gdb_packet(): to much data\n");
1122
1123   /* start with the packet header */
1124   p = buf;
1125   *p++ = '$';
1126
1127   /* calculate the checksum */
1128   for (i = 0; i < cnt; i++) {
1129     csum += data[i];
1130     *p++ = data[i];
1131   }
1132
1133   /* terminate the data with a '#' */
1134   *p++ = '#';
1135
1136   /* add the checksum as two ascii digits */
1137   *p++ = tohex ((csum >> 4) & 0xf);
1138   *p++ = tohex (csum & 0xf);
1139   *p  = 0x0;                    /* Null terminator on string */
1140 }
1141
1142 /*
1143  * array_send_packet -- send a GDB packet to the target with error handling. We
1144  *              get a '+' (ACK) back if the packet is received and the checksum
1145  *              matches. Otherwise a '-' (NAK) is returned. It returns a 1 for a
1146  *              successful transmition, or a 0 for a failure.
1147  */
1148 static int
1149 array_send_packet (packet)
1150      char *packet;
1151 {
1152   int c, retries, i;
1153   char junk[PBUFSIZ];
1154
1155   retries = 0;
1156
1157 #if 0
1158   /* scan the packet to make sure it only contains valid characters.
1159      this may sound silly, but sometimes a garbled packet will hang
1160      the target board. We scan the whole thing, then print the error
1161      message.
1162      */
1163   for (i = 0; i < strlen(packet); i++) {
1164     debuglogs (5, "array_send_packet(): Scanning \'%c\'\n", packet[i]);
1165     /* legit hex numbers or command */
1166     if ((isxdigit(packet[i])) || (isalpha(packet[i])))
1167       continue;
1168     switch (packet[i]) {
1169     case '+':                   /* ACK */
1170     case '-':                   /* NAK */
1171     case '#':                   /* end of packet */
1172     case '$':                   /* start of packet */
1173       continue;
1174     default:                    /* bogus character */
1175       retries++;
1176       debuglogs (4, "array_send_packet(): Found a non-ascii digit \'%c\' in the packet.\n", packet[i]);
1177     }
1178   }
1179 #endif
1180
1181   if (retries > 0)
1182     error ("Can't send packet, found %d non-ascii characters", retries);
1183
1184   /* ok, try to send the packet */
1185   retries = 0;
1186   while (retries++ <= 10) {
1187     printf_monitor ("%s", packet);
1188
1189     /* read until either a timeout occurs (-2) or '+' is read */
1190     while (retries <= 10) {
1191       c = readchar (-timeout);
1192       debuglogs (3, "Reading a GDB protocol packet... Got a '%c'\n", c);
1193       switch (c) {
1194       case '+':
1195         debuglogs (3, "Got Ack\n");
1196         return 1;
1197       case SERIAL_TIMEOUT:
1198         debuglogs (3, "Timed out reading serial port\n");
1199         printf_monitor("+");            /* resync with the monitor */
1200        expect_prompt(1);                /* See if we get a expect_prompt */
1201         break;            /* Retransmit buffer */
1202       case '-':
1203         debuglogs (3, "Got NAK\n");
1204         printf_monitor("+");            /* resync with the monitor */
1205        expect_prompt(1);                /* See if we get a expect_prompt */
1206         break;
1207       case '$':
1208         /* it's probably an old response, or the echo of our command.
1209          * just gobble up the packet and ignore it.
1210          */
1211         debuglogs (3, "Got a junk packet\n");
1212         i = 0;
1213         do {
1214           c = readchar (timeout);
1215           junk[i++] = c;
1216         } while (c != '#');
1217         c = readchar (timeout);
1218         junk[i++] = c;
1219         c = readchar (timeout);
1220         junk[i++] = c;
1221         junk[i++] = '\0';
1222         debuglogs (3, "Reading a junk packet, got a \"%s\"\n", junk);
1223         continue;               /* Now, go look for next packet */
1224       default:
1225         continue;
1226       }
1227       retries++;
1228       debuglogs (3, "Retransmitting packet \"%s\"\n", packet);
1229       break;                /* Here to retransmit */
1230     }
1231   } /* outer while */
1232   return 0;
1233 }
1234
1235 /*
1236  * array_get_packet -- get a GDB packet from the target. Basically we read till we
1237  *              see a '#', then check the checksum. It returns a 1 if it's gotten a
1238  *              packet, or a 0 it the packet wasn't transmitted correctly.
1239  */
1240 static int
1241 array_get_packet (packet)
1242      char *packet;
1243 {
1244   int c;
1245   int retries;
1246   unsigned char csum;
1247   unsigned char pktcsum;
1248   char *bp;
1249
1250   csum = 0;
1251   bp = packet;
1252
1253   memset (packet, 1, PBUFSIZ);
1254   retries = 0;
1255   while (retries <= 10) {
1256     do {
1257       c = readchar (timeout);
1258       if (c == SERIAL_TIMEOUT) {
1259         debuglogs (3, "array_get_packet: got time out from serial port.\n");
1260       }
1261       debuglogs (3, "Waiting for a '$', got a %c\n", c);
1262     } while (c != '$');
1263
1264     retries = 0;
1265     while (retries <= 10) {
1266       c = readchar (timeout);
1267       debuglogs (3, "array_get_packet: got a '%c'\n", c);
1268       switch (c) {
1269       case SERIAL_TIMEOUT:
1270         debuglogs (3, "Timeout in mid-packet, retrying\n");
1271         return 0;
1272       case '$':
1273         debuglogs (3, "Saw new packet start in middle of old one\n");
1274         return 0;             /* Start a new packet, count retries */
1275       case '#':
1276         *bp = '\0';
1277         pktcsum = from_hex (readchar (timeout)) << 4;
1278         pktcsum |= from_hex (readchar (timeout));
1279         if (csum == 0)
1280           debuglogs (3, "\nGDB packet checksum zero, must be a bogus packet\n");
1281         if (csum == pktcsum) {
1282           debuglogs (3, "\nGDB packet checksum correct, packet data is \"%s\",\n", packet);
1283           printf_monitor ("+");
1284          expect_prompt (1);
1285           return 1;
1286         }
1287         debuglogs (3, "Bad checksum, sentsum=0x%x, csum=0x%x\n", pktcsum, csum);
1288         return 0;
1289       case '*':               /* Run length encoding */
1290         debuglogs (5, "Run length encoding in packet\n");
1291         csum += c;
1292         c = readchar (timeout);
1293         csum += c;
1294         c = c - ' ' + 3;      /* Compute repeat count */
1295
1296         if (c > 0 && c < 255 && bp + c - 1 < packet + PBUFSIZ - 1) {
1297           memset (bp, *(bp - 1), c);
1298           bp += c;
1299           continue;
1300         }
1301         *bp = '\0';
1302         printf_filtered ("Repeat count %d too large for buffer.\n", c);
1303         return 0;
1304
1305       default:
1306         if ((!isxdigit(c)) && (!ispunct(c)))
1307           debuglogs (4, "Got a non-ascii digit \'%c\'.\\n", c);
1308         if (bp < packet + PBUFSIZ - 1) {
1309           *bp++ = c;
1310           csum += c;
1311           continue;
1312         }
1313
1314         *bp = '\0';
1315         puts_filtered ("Remote packet too long.\n");
1316         return 0;
1317       }
1318     }
1319   }
1320 }
1321
1322 /*
1323  * ascii2hexword -- convert an ascii number represented by 8 digits to a hex value.
1324  */
1325 static unsigned long
1326 ascii2hexword (mem)
1327      unsigned char *mem;
1328 {
1329   unsigned long val;
1330   int i;
1331   char buf[9];
1332
1333   val = 0;
1334   for (i = 0; i < 8; i++) {
1335     val <<= 4;
1336     if (mem[i] >= 'A' && mem[i] <= 'F')
1337       val = val + mem[i] - 'A' + 10;
1338     if (mem[i] >= 'a' && mem[i] <= 'f')
1339       val = val + mem[i] - 'a' + 10;
1340     if (mem[i] >= '0' && mem[i] <= '9')
1341       val = val + mem[i] - '0';
1342     buf[i] = mem[i];
1343   }
1344   buf[8] = '\0';
1345   debuglogs (4, "ascii2hexword() got a 0x%x from %s(%x).\n", val, buf, mem);
1346   return val;
1347 }
1348
1349 /*
1350  * ascii2hexword -- convert a hex value to an ascii number represented by 8
1351  *      digits.
1352  */
1353 static char*
1354 hexword2ascii (mem, num)
1355      unsigned char *mem;
1356      unsigned long num;
1357 {
1358   int i;
1359   unsigned char ch;
1360
1361   debuglogs (4, "hexword2ascii() converting %x ", num);
1362   for (i = 7; i >= 0; i--) {
1363     mem[i] = tohex ((num >> 4) & 0xf);
1364     mem[i] = tohex (num & 0xf);
1365     num = num >> 4;
1366   }
1367   mem[8] = '\0';
1368   debuglogs (4, "\tto a %s", mem);
1369 }
1370
1371 /* Convert hex digit A to a number.  */
1372 static int
1373 from_hex (a)
1374      int a;
1375 {
1376   if (a == 0)
1377     return 0;
1378
1379   debuglogs (4, "from_hex got a 0x%x(%c)\n",a,a);
1380   if (a >= '0' && a <= '9')
1381     return a - '0';
1382   if (a >= 'a' && a <= 'f')
1383     return a - 'a' + 10;
1384   if (a >= 'A' && a <= 'F')
1385     return a - 'A' + 10;
1386   else {
1387     error ("Reply contains invalid hex digit 0x%x", a);
1388   }
1389 }
1390
1391 /* Convert number NIB to a hex digit.  */
1392 static int
1393 tohex (nib)
1394      int nib;
1395 {
1396   if (nib < 10)
1397     return '0'+nib;
1398   else
1399     return 'a'+nib-10;
1400 }
1401
1402 /*
1403  * _initialize_remote_monitors -- setup a few addtitional commands that
1404  *              are usually only used by monitors.
1405  */
1406 void
1407 _initialize_remote_monitors ()
1408 {
1409   /* generic monitor command */
1410   add_com ("monitor", class_obscure, monitor_command,
1411            "Send a command to the debug monitor.");
1412
1413 }
1414
1415 /*
1416  * _initialize_array -- do any special init stuff for the target.
1417  */
1418 void
1419 _initialize_array ()
1420 {
1421   add_target (&array_ops);
1422   baud_rate = 4800;                     /* this is the only supported baud rate */
1423 }
1424