gdb/remote-array.c

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