gdb/remote-hms.c

   1 /* Remote debugging interface for Hitachi HMS Monitor Version 1.0
   2    Copyright 1992, 1993, 1994 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.  Written by Steve Chamberlain
   4    (sac@cygnus.com).
   5
   6 This file is part of GDB.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program; if not, write to the Free Software
  20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  21
  22 #include "defs.h"
  23 #include "inferior.h"
  24 #include "wait.h"
  25 #include "value.h"
  26 #include <string.h>
  27 #include <ctype.h>
  28 #include <fcntl.h>
  29 #include <signal.h>
  30 #include <setjmp.h>
  31 #include <errno.h>
  32 #include "terminal.h"
  33 #include "target.h"
  34 #include "gdbcore.h"
  35 #include "serial.h"
  36
  37 /* External data declarations */
  38 extern int stop_soon_quietly;   /* for wait_for_inferior */
  39
  40 /* Forward data declarations */
  41 extern struct target_ops hms_ops;       /* Forward declaration */
  42
  43 /* Forward function declarations */
  44 static void hms_fetch_registers ();
  45 static int hms_store_registers ();
  46 static void hms_close ();
  47 static int hms_clear_breakpoints ();
  48
  49 extern struct target_ops hms_ops;
  50 static void hms_drain ();
  51 static void add_commands ();
  52 static void remove_commands ();
  53
  54 static int quiet = 1;
  55
  56
  57 serial_t desc;
  58
  59 /***********************************************************************/
  60 /* Caching stuff stolen from remote-nindy.c  */
  61
  62 /* The data cache records all the data read from the remote machine
  63    since the last time it stopped.
  64
  65    Each cache block holds LINE_SIZE bytes of data
  66    starting at a multiple-of-LINE_SIZE address.  */
  67
  68 #define LINE_SIZE_POWER 4
  69 #define LINE_SIZE (1<<LINE_SIZE_POWER)  /* eg 1<<3 == 8 */
  70 #define LINE_SIZE_MASK ((LINE_SIZE-1))  /* eg 7*2+1= 111*/
  71 #define DCACHE_SIZE 64          /* Number of cache blocks */
  72 #define XFORM(x)  ((x&LINE_SIZE_MASK)>>2)
  73 struct dcache_block
  74   {
  75     struct dcache_block *next, *last;
  76     unsigned int addr;          /* Address for which data is recorded.  */
  77     int data[LINE_SIZE / sizeof (int)];
  78   };
  79
  80 struct dcache_block dcache_free, dcache_valid;
  81
  82 /* Free all the data cache blocks, thus discarding all cached data.  */
  83 static
  84 void
  85 dcache_flush ()
  86 {
  87   register struct dcache_block *db;
  88
  89   while ((db = dcache_valid.next) != &dcache_valid)
  90     {
  91       remque (db);
  92       insque (db, &dcache_free);
  93     }
  94 }
  95
  96 /*
  97  * If addr is present in the dcache, return the address of the block
  98  * containing it.
  99  */
 100 static
 101 struct dcache_block *
 102 dcache_hit (addr)
 103      unsigned int addr;
 104 {
 105   register struct dcache_block *db;
 106
 107   if (addr & 3)
 108     abort ();
 109
 110   /* Search all cache blocks for one that is at this address.  */
 111   db = dcache_valid.next;
 112   while (db != &dcache_valid)
 113     {
 114       if ((addr & ~LINE_SIZE_MASK) == db->addr)
 115         return db;
 116       db = db->next;
 117     }
 118   return NULL;
 119 }
 120
 121 /*  Return the int data at address ADDR in dcache block DC.  */
 122 static
 123 int
 124 dcache_value (db, addr)
 125      struct dcache_block *db;
 126      unsigned int addr;
 127 {
 128   if (addr & 3)
 129     abort ();
 130   return (db->data[XFORM (addr)]);
 131 }
 132
 133 /* Get a free cache block, put or keep it on the valid list,
 134    and return its address.  The caller should store into the block
 135    the address and data that it describes, then remque it from the
 136    free list and insert it into the valid list.  This procedure
 137    prevents errors from creeping in if a ninMemGet is interrupted
 138    (which used to put garbage blocks in the valid list...).  */
 139 static
 140 struct dcache_block *
 141 dcache_alloc ()
 142 {
 143   register struct dcache_block *db;
 144
 145   if ((db = dcache_free.next) == &dcache_free)
 146     {
 147       /* If we can't get one from the free list, take last valid and put
 148          it on the free list.  */
 149       db = dcache_valid.last;
 150       remque (db);
 151       insque (db, &dcache_free);
 152     }
 153
 154   remque (db);
 155   insque (db, &dcache_valid);
 156   return (db);
 157 }
 158
 159 /* Return the contents of the word at address ADDR in the remote machine,
 160    using the data cache.  */
 161 static
 162 int
 163 dcache_fetch (addr)
 164      CORE_ADDR addr;
 165 {
 166   register struct dcache_block *db;
 167
 168   db = dcache_hit (addr);
 169   if (db == 0)
 170     {
 171       db = dcache_alloc ();
 172       immediate_quit++;
 173       hms_read_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
 174       immediate_quit--;
 175       db->addr = addr & ~LINE_SIZE_MASK;
 176       remque (db);              /* Off the free list */
 177       insque (db, &dcache_valid);       /* On the valid list */
 178     }
 179   return (dcache_value (db, addr));
 180 }
 181
 182 /* Write the word at ADDR both in the data cache and in the remote machine.  */
 183 static void
 184 dcache_poke (addr, data)
 185      CORE_ADDR addr;
 186      int data;
 187 {
 188   register struct dcache_block *db;
 189
 190   /* First make sure the word is IN the cache.  DB is its cache block.  */
 191   db = dcache_hit (addr);
 192   if (db == 0)
 193     {
 194       db = dcache_alloc ();
 195       immediate_quit++;
 196       hms_write_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
 197       immediate_quit--;
 198       db->addr = addr & ~LINE_SIZE_MASK;
 199       remque (db);              /* Off the free list */
 200       insque (db, &dcache_valid);       /* On the valid list */
 201     }
 202
 203   /* Modify the word in the cache.  */
 204   db->data[XFORM (addr)] = data;
 205
 206   /* Send the changed word.  */
 207   immediate_quit++;
 208   hms_write_inferior_memory (addr, (unsigned char *) &data, 4);
 209   immediate_quit--;
 210 }
 211
 212 /* The cache itself. */
 213 struct dcache_block the_cache[DCACHE_SIZE];
 214
 215 /* Initialize the data cache.  */
 216 static void
 217 dcache_init ()
 218 {
 219   register i;
 220   register struct dcache_block *db;
 221
 222   db = the_cache;
 223   dcache_free.next = dcache_free.last = &dcache_free;
 224   dcache_valid.next = dcache_valid.last = &dcache_valid;
 225   for (i = 0; i < DCACHE_SIZE; i++, db++)
 226     insque (db, &dcache_free);
 227 }
 228
 229 /***********************************************************************
 230  * I/O stuff stolen from remote-eb.c
 231  ***********************************************************************/
 232
 233 static int timeout = 2;
 234
 235 static const char *dev_name;
 236
 237 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 238    hms_open knows that we don't have a file open when the program
 239    starts.  */
 240
 241 int is_open = 0;
 242 int
 243 check_open ()
 244 {
 245   if (!is_open)
 246     {
 247       error ("remote device not open");
 248     }
 249 }
 250
 251 #define ON      1
 252 #define OFF     0
 253
 254 /* Read a character from the remote system, doing all the fancy
 255    timeout stuff.  */
 256 static int
 257 readchar ()
 258 {
 259   int buf;
 260
 261   buf = SERIAL_READCHAR (desc, timeout);
 262
 263   if (buf == SERIAL_TIMEOUT)
 264     {
 265       hms_write (".\r\n", 3);
 266       error ("Timeout reading from remote system.");
 267     }
 268   if (buf == SERIAL_ERROR)
 269     {
 270       error ("Serial port error!");
 271     }
 272
 273   if (!quiet)
 274     printf_unfiltered ("%c", buf);
 275
 276   return buf & 0x7f;
 277 }
 278
 279 static int
 280 readchar_nofail ()
 281 {
 282   int buf;
 283
 284   buf = SERIAL_READCHAR (desc, timeout);
 285   if (buf == SERIAL_TIMEOUT)
 286     buf = 0;
 287   if (!quiet)
 288     printf_unfiltered ("%c", buf);
 289
 290   return buf & 0x7f;
 291
 292 }
 293
 294 /* Keep discarding input from the remote system, until STRING is found.
 295    Let the user break out immediately.  */
 296 static void
 297 expect (string)
 298      char *string;
 299 {
 300   char *p = string;
 301
 302   immediate_quit = 1;
 303   while (1)
 304     {
 305       if (readchar () == *p)
 306         {
 307           p++;
 308           if (*p == '\0')
 309             {
 310               immediate_quit = 0;
 311               return;
 312             }
 313         }
 314       else
 315         p = string;
 316     }
 317 }
 318
 319 /* Keep discarding input until we see the hms prompt.
 320
 321    The convention for dealing with the prompt is that you
 322    o give your command
 323    o *then* wait for the prompt.
 324
 325    Thus the last thing that a procedure does with the serial line
 326    will be an expect_prompt().  Exception:  hms_resume does not
 327    wait for the prompt, because the terminal is being handed over
 328    to the inferior.  However, the next thing which happens after that
 329    is a hms_wait which does wait for the prompt.
 330    Note that this includes abnormal exit, e.g. error().  This is
 331    necessary to prevent getting into states from which we can't
 332    recover.  */
 333 static void
 334 expect_prompt ()
 335 {
 336   expect ("HMS>");
 337 }
 338
 339 /* Get a hex digit from the remote system & return its value.
 340    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 341 static int
 342 get_hex_digit (ignore_space)
 343      int ignore_space;
 344 {
 345   int ch;
 346
 347   while (1)
 348     {
 349       ch = readchar ();
 350       if (ch >= '0' && ch <= '9')
 351         return ch - '0';
 352       else if (ch >= 'A' && ch <= 'F')
 353         return ch - 'A' + 10;
 354       else if (ch >= 'a' && ch <= 'f')
 355         return ch - 'a' + 10;
 356       else if (ch == ' ' && ignore_space)
 357         ;
 358       else
 359         {
 360           expect_prompt ();
 361           error ("Invalid hex digit from remote system.");
 362         }
 363     }
 364 }
 365
 366 /* Get a byte from hms_desc and put it in *BYT.  Accept any number
 367    leading spaces.  */
 368 static void
 369 get_hex_byte (byt)
 370      char *byt;
 371 {
 372   int val;
 373
 374   val = get_hex_digit (1) << 4;
 375   val |= get_hex_digit (0);
 376   *byt = val;
 377 }
 378
 379 /* Read a 32-bit hex word from the hms, preceded by a space  */
 380 static long
 381 get_hex_word ()
 382 {
 383   long val;
 384   int j;
 385
 386   val = 0;
 387   for (j = 0; j < 8; j++)
 388     val = (val << 4) + get_hex_digit (j == 0);
 389   return val;
 390 }
 391
 392 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 393
 394 /* Number of SIGTRAPs we need to simulate.  That is, the next
 395    NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
 396    SIGTRAP without actually waiting for anything.  */
 397
 398 static int need_artificial_trap = 0;
 399
 400 void
 401 hms_kill (arg, from_tty)
 402      char *arg;
 403      int from_tty;
 404 {
 405
 406 }
 407
 408 /*
 409  * Download a file specified in 'args', to the hms.
 410  */
 411 static void
 412 hms_load (args, fromtty)
 413      char *args;
 414      int fromtty;
 415 {
 416   bfd *abfd;
 417   asection *s;
 418   int n;
 419   char buffer[1024];
 420
 421   check_open ();
 422
 423   dcache_flush ();
 424   inferior_pid = 0;
 425   abfd = bfd_openr (args, gnutarget);
 426   if (!abfd)
 427     {
 428       printf_filtered ("Unable to open file %s\n", args);
 429       return;
 430     }
 431
 432   if (bfd_check_format (abfd, bfd_object) == 0)
 433     {
 434       printf_filtered ("File is not an object file\n");
 435       return;
 436     }
 437
 438   s = abfd->sections;
 439   while (s != (asection *) NULL)
 440     {
 441       if (s->flags & SEC_LOAD)
 442         {
 443           int i;
 444
 445 #define DELTA 1024
 446           char *buffer = xmalloc (DELTA);
 447
 448           printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma, s->vma + s->_raw_size);
 449           for (i = 0; i < s->_raw_size; i += DELTA)
 450             {
 451               int delta = DELTA;
 452
 453               if (delta > s->_raw_size - i)
 454                 delta = s->_raw_size - i;
 455
 456               bfd_get_section_contents (abfd, s, buffer, i, delta);
 457               hms_write_inferior_memory (s->vma + i, buffer, delta);
 458               printf_filtered ("*");
 459               gdb_flush (gdb_stdout);
 460             }
 461           printf_filtered ("\n");
 462           free (buffer);
 463         }
 464       s = s->next;
 465     }
 466   sprintf (buffer, "r PC=%x", abfd->start_address);
 467   hms_write_cr (buffer);
 468   expect_prompt ();
 469   /* Turn off all breakpoints */
 470   hms_write_cr ("b -");
 471   expect_prompt ();
 472 }
 473
 474 /* This is called not only when we first attach, but also when the
 475    user types "run" after having attached.  */
 476 void
 477 hms_create_inferior (execfile, args, env)
 478      char *execfile;
 479      char *args;
 480      char **env;
 481 {
 482   int entry_pt;
 483   char buffer[100];
 484
 485   if (args && *args)
 486     error ("Can't pass arguments to remote hms process.");
 487
 488   if (execfile == 0 || exec_bfd == 0)
 489     error ("No exec file specified");
 490
 491   entry_pt = (int) bfd_get_start_address (exec_bfd);
 492   check_open ();
 493
 494   hms_kill (NULL, NULL);
 495   hms_clear_breakpoints ();
 496   init_wait_for_inferior ();
 497   hms_write_cr ("");
 498   expect_prompt ();
 499
 500   insert_breakpoints ();        /* Needed to get correct instruction in cache */
 501   proceed (entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 502 }
 503
 504 /* Open a connection to a remote debugger.
 505    NAME is the filename used for communication, then a space,
 506    then the baud rate.
 507  */
 508
 509 static char *
 510 find_end_of_word (s)
 511      char *s;
 512 {
 513   while (*s && !isspace (*s))
 514     s++;
 515   return s;
 516 }
 517
 518 static char *
 519 get_word (p)
 520      char **p;
 521 {
 522   char *s = *p;
 523   char *word;
 524   char *copy;
 525   size_t len;
 526
 527   while (isspace (*s))
 528     s++;
 529
 530   word = s;
 531
 532   len = 0;
 533
 534   while (*s && !isspace (*s))
 535     {
 536       s++;
 537       len++;
 538
 539     }
 540   copy = xmalloc (len + 1);
 541   memcpy (copy, word, len);
 542   copy[len] = 0;
 543   *p = s;
 544   return copy;
 545 }
 546
 547 static int baudrate = 9600;
 548
 549 static int
 550 is_baudrate_right ()
 551 {
 552   int ok;
 553
 554   /* Put this port into NORMAL mode, send the 'normal' character */
 555
 556   hms_write ("\001", 1);        /* Control A */
 557   hms_write ("\r\n", 2);        /* Cr */
 558
 559   while (1)
 560     {
 561       ok = SERIAL_READCHAR (desc, timeout);
 562       if (ok < 0)
 563         break;
 564     }
 565
 566   hms_write ("r", 1);
 567
 568   if (readchar_nofail () == 'r')
 569     return 1;
 570
 571   /* Not the right baudrate, or the board's not on */
 572   return 0;
 573 }
 574 static void
 575 set_rate ()
 576 {
 577   if (!SERIAL_SETBAUDRATE (desc, baudrate))
 578     error ("Can't set baudrate");
 579 }
 580
 581
 582 static void
 583 hms_open (name, from_tty)
 584      char *name;
 585      int from_tty;
 586 {
 587   unsigned int prl;
 588   char *p;
 589
 590   if (name == 0)
 591     {
 592       name = "";
 593     }
 594   if (is_open)
 595     hms_close (0);
 596   dev_name = strdup (name);
 597
 598   if (!(desc = SERIAL_OPEN (dev_name)))
 599     perror_with_name ((char *) dev_name);
 600
 601   SERIAL_RAW (desc);
 602   is_open = 1;
 603   push_target (&hms_ops);
 604   dcache_init ();
 605
 606   /* Hello?  Are you there?  */
 607   SERIAL_WRITE (desc, "\r\n", 2);
 608   expect_prompt ();
 609
 610   /* Clear any break points */
 611   hms_clear_breakpoints ();
 612
 613   printf_filtered ("Connected to remote board running HMS monitor.\n");
 614   add_commands ();
 615   hms_drain ();
 616 }
 617
 618 /* Close out all files and local state before this target loses control. */
 619
 620 static void
 621 hms_close (quitting)
 622      int quitting;
 623 {
 624   /* Clear any break points */
 625   remove_commands ();
 626   hms_clear_breakpoints ();
 627   sleep (1);                    /* Let any output make it all the way back */
 628   if (is_open)
 629     {
 630       SERIAL_WRITE (desc, "R\r\n", 3);
 631       SERIAL_CLOSE (desc);
 632     }
 633   is_open = 0;
 634 }
 635
 636 /* Terminate the open connection to the remote debugger.  Use this
 637 when you want to detach and do something else with your gdb.  */ void
 638 hms_detach (args, from_tty)
 639      char *args;
 640      int from_tty;
 641 {
 642   if (is_open)
 643     {
 644       hms_clear_breakpoints ();
 645     }
 646
 647   pop_target ();                /* calls hms_close to do the real work
 648 */
 649   if (from_tty)
 650     printf_filtered ("Ending remote %s debugging\n",
 651                      target_shortname);
 652 }
 653
 654 /* Tell the remote machine to resume.  */
 655
 656 void
 657 hms_resume (pid, step, sig)
 658      int pid, step;
 659      enum target_signal
 660        sig;
 661 {
 662   dcache_flush ();
 663
 664   if (step)
 665     {
 666       hms_write_cr ("s");
 667       expect ("Step>");
 668
 669       /* Force the next hms_wait to return a trap.  Not doing anything
 670          about I/O from the target means that the user has to type "continue"
 671             to see any.  FIXME, this should be fixed.  */
 672       need_artificial_trap = 1;
 673     }
 674   else
 675     {
 676       hms_write_cr ("g");
 677       expect ("g");
 678     }
 679 }
 680
 681 /* Wait until the remote machine stops, then return, storing status in
 682 STATUS just as `wait' would.  */
 683
 684 int
 685 hms_wait (pid, status)
 686      int pid;
 687      struct target_waitstatus *status;
 688 {
 689   /* Strings to look for.  '?' means match any single character.  Note
 690      that with the algorithm we use, the initial character of the string
 691      cannot recur in the string, or we will not find some cases of the
 692      string in the input.  */
 693
 694   static char bpt[] = "At breakpoint:";
 695
 696   /* It would be tempting to look for "\n[__exit + 0x8]\n" but that
 697      requires loading symbols with "yc i" and even if we did do that we
 698      don't know that the file has symbols.  */
 699   static char exitmsg[] =  "HMS>";
 700   char *bp = bpt;
 701   char *ep = exitmsg;
 702
 703   /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars.
 704    */
 705   char swallowed[50];
 706
 707   /* Current position in swallowed.  */
 708   char *swallowed_p = swallowed;
 709
 710   int ch;
 711   int ch_handled;
 712   int old_timeout = timeout;
 713   int
 714     old_immediate_quit = immediate_quit;
 715   int swallowed_cr = 0;
 716
 717   status->kind = TARGET_WAITKIND_EXITED;
 718   status->value.integer = 0;
 719
 720   if (need_artificial_trap != 0)
 721     {
 722       status->kind =
 723         TARGET_WAITKIND_STOPPED;
 724       status->value.sig = TARGET_SIGNAL_TRAP;
 725       need_artificial_trap--;
 726       return 0;
 727     }
 728
 729   timeout = 5;                  /* Don't time out for a while - user program is running.
 730                                  */
 731   immediate_quit = 1;           /* Helps ability to QUIT */
 732   while (1)
 733     {
 734       QUIT;                     /* Let user quit and leave process running */
 735       ch_handled = 0;
 736       ch = readchar ();
 737       if (ch == *bp)
 738         {
 739           bp++;
 740           if (*bp == '\0')
 741             break;
 742           ch_handled = 1;
 743
 744           *swallowed_p++ = ch;
 745         }
 746       else
 747         {
 748           bp = bpt;
 749         }
 750       if
 751         (ch == *ep || *ep == '?')
 752           {
 753             ep++;
 754             if (*ep == '\0')
 755               break;
 756
 757             if (!ch_handled)
 758               *swallowed_p++ = ch;
 759             ch_handled =
 760               1;
 761           }
 762       else
 763         {
 764           ep = exitmsg;
 765         }
 766
 767       if (!ch_handled)
 768         {
 769           char *p;
 770
 771           /* Print out any characters which have been swallowed.  */
 772           for (p = swallowed; p < swallowed_p; ++p)
 773             putc_unfiltered (*p);
 774           swallowed_p = swallowed;
 775
 776           if ((ch != '\r' && ch != '\n') || swallowed_cr > 10)
 777             {
 778               putc_unfiltered (ch);
 779               swallowed_cr = 10;
 780             }
 781           swallowed_cr++;
 782
 783         }
 784     }
 785   if (*bp == '\0')
 786     {
 787       status->kind = TARGET_WAITKIND_STOPPED;
 788       status->value.sig = TARGET_SIGNAL_TRAP;
 789       expect_prompt ();
 790     }
 791   else
 792     {
 793       status->kind = TARGET_WAITKIND_EXITED;
 794       status->value.integer =
 795         TARGET_SIGNAL_STOP;
 796     }
 797
 798   timeout = old_timeout;
 799   immediate_quit = old_immediate_quit;
 800   return
 801     0;
 802 }
 803
 804 /* Return the name of register number REGNO in the form input and
 805 output by hms.
 806
 807    Returns a pointer to a static buffer containing the answer.  */
 808 static char *
 809 get_reg_name (regno)
 810      int regno;
 811 {
 812   static char *rn[] =
 813   REGISTER_NAMES;
 814
 815   return rn[regno];
 816 }
 817
 818 /* Read the remote registers.  */
 819
 820 static int
 821 gethex (length, start, ok)
 822      unsigned int length;
 823      char *start;
 824      int *ok;
 825 {
 826   int result = 0;
 827
 828   while (length--)
 829     {
 830       result <<= 4;
 831       if (*start >= 'a' && *start <= 'f')
 832         {
 833           result += *start - 'a' + 10;
 834         }
 835       else if (*start >= 'A' &&
 836                *start <= 'F')
 837         {
 838           result += *start - 'A' + 10;
 839         }
 840       else if
 841         (*start >= '0' && *start <= '9')
 842           {
 843             result += *start - '0';
 844           }
 845       else
 846         *ok = 0;
 847       start++;
 848
 849     }
 850   return result;
 851 }
 852 static int
 853 timed_read (buf, n, timeout)
 854      char
 855       *buf;
 856
 857 {
 858   int i;
 859   char c;
 860
 861   i = 0;
 862   while (i < n)
 863     {
 864       c = readchar ();
 865
 866       if (c == 0)
 867         return i;
 868       buf[i] = c;
 869       i++;
 870
 871     }
 872   return i;
 873 }
 874
 875 hms_write (a, l)
 876      char *a;
 877 {
 878   int i;
 879
 880   SERIAL_WRITE (desc, a, l);
 881
 882   if (!quiet)
 883     {
 884       printf_unfiltered ("<");
 885       for (i = 0; i < l; i++)
 886         {
 887           printf_unfiltered ("%c", a[i]);
 888         }
 889       printf_unfiltered (">");
 890     }
 891 }
 892
 893 hms_write_cr (s)
 894      char *s;
 895 {
 896   hms_write (s, strlen (s));
 897   hms_write ("\r\n", 2);
 898 }
 899
 900 #ifdef GDB_TARGET_IS_H8500
 901
 902 /* H8/500 monitor reg dump looks like:
 903
 904 HMS>r
 905 PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00
 906 R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE
 907 HMS>
 908
 909
 910 */
 911
 912 supply_val (n, size, ptr, segptr)
 913      int n;
 914      int size;
 915      char *ptr;
 916      char *segptr;
 917 {
 918   int ok;
 919   char raw[4];
 920   switch (size)
 921     {
 922     case 2:
 923       raw[0] = gethex (2, ptr, &ok);
 924       raw[1] = gethex (2, ptr + 2, &ok);
 925       supply_register (n, raw);
 926       break;
 927     case 1:
 928       raw[0] = gethex (2, ptr, &ok);
 929       supply_register (n, raw);
 930       break;
 931     case 4:
 932       {
 933         int v = gethex (4, ptr, &ok);
 934         v |= gethex (2, segptr, &ok) << 16;
 935         raw[0] = 0;
 936         raw[1] = (v >> 16) & 0xff;
 937         raw[2] = (v >> 8) & 0xff;
 938         raw[3] = (v >> 0) & 0xff;
 939         supply_register (n, raw);
 940       }
 941     }
 942
 943 }
 944 static void
 945 hms_fetch_register (dummy)
 946      int dummy;
 947 {
 948 #define REGREPLY_SIZE 108
 949   char linebuf[REGREPLY_SIZE + 1];
 950   int i;
 951   int s;
 952   int gottok;
 953
 954   LONGEST reg[NUM_REGS];
 955   check_open ();
 956
 957   do
 958     {
 959
 960       hms_write_cr ("r");
 961       expect ("r");
 962       s = timed_read (linebuf + 1, REGREPLY_SIZE, 1);
 963
 964       linebuf[REGREPLY_SIZE] = 0;
 965       gottok = 0;
 966       if (linebuf[3] == 'P' &&
 967           linebuf[4] == 'C' &&
 968           linebuf[5] == ':' &&
 969           linebuf[105] == 'H' &&
 970           linebuf[106] == 'M' &&
 971           linebuf[107] == 'S')
 972         {
 973
 974           /*
 975             012
 976             r**
 977             -------1---------2---------3---------4---------5-----
 978             345678901234567890123456789012345678901234567890123456
 979             PC:8000 SR:070C .7NZ.. CP:00 DP:00 EP:00 TP:00 BR:00**
 980             ---6---------7---------8---------9--------10----
 981             789012345678901234567890123456789012345678901234
 982             R0-R7: FF5A 0001 F4FE F500 0000 F528 F528 F4EE**
 983
 984             56789
 985             HMS>
 986             */
 987           gottok = 1;
 988
 989
 990           supply_val (PC_REGNUM, 4, linebuf + 6, linebuf + 29);
 991
 992           supply_val (CCR_REGNUM, 2, linebuf + 14);
 993           supply_val (SEG_C_REGNUM, 1, linebuf + 29);
 994           supply_val (SEG_D_REGNUM, 1, linebuf + 35);
 995           supply_val (SEG_E_REGNUM, 1, linebuf + 41);
 996           supply_val (SEG_T_REGNUM, 1, linebuf + 47);
 997           for (i = 0; i < 8; i++)
 998             {
 999               static int sr[8] =
1000               {35, 35, 35, 35,
1001                41, 41, 47, 47};
1002
1003               char raw[4];
1004               char *src = linebuf + 64 + 5 * i;
1005               char *segsrc = linebuf + sr[i];
1006               supply_val (R0_REGNUM + i, 2, src);
1007               supply_val (PR0_REGNUM + i, 4, src, segsrc);
1008             }
1009         }
1010       if (!gottok)
1011         {
1012           hms_write_cr ("");
1013           expect ("HMS>");
1014         }
1015     }
1016   while (!gottok);
1017 }
1018 #endif
1019
1020 #ifdef GDB_TARGET_IS_H8300
1021 static void
1022 hms_fetch_register (dummy)
1023      int dummy;
1024 {
1025 #define REGREPLY_SIZE 79
1026   char linebuf[REGREPLY_SIZE + 1];
1027   int i;
1028   int s;
1029   int gottok;
1030
1031   unsigned LONGEST reg[NUM_REGS];
1032
1033   check_open ();
1034
1035   do
1036     {
1037       hms_write_cr ("r");
1038
1039       s = timed_read (linebuf, 1, 1);
1040
1041       while (linebuf[0] != 'r')
1042         s = timed_read (linebuf, 1, 1);
1043
1044       s = timed_read (linebuf + 1, REGREPLY_SIZE - 1, 1);
1045
1046       linebuf[REGREPLY_SIZE] = 0;
1047       gottok = 0;
1048       if (linebuf[0] == 'r' &&
1049           linebuf[3] == 'P' &&
1050           linebuf[4] == 'C' &&
1051           linebuf[5] == '=' &&
1052           linebuf[75] == 'H' &&
1053           linebuf[76] == 'M' &&
1054           linebuf[77] == 'S')
1055         {
1056           /*
1057         PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
1058         5436789012345678901234567890123456789012345678901234567890123456789012
1059         0      1         2         3         4         5         6
1060         */
1061           gottok = 1;
1062
1063           reg[PC_REGNUM] = gethex (4, linebuf + 6, &gottok);
1064           reg[CCR_REGNUM] = gethex (2, linebuf + 15, &gottok);
1065           for (i = 0; i < 8; i++)
1066             {
1067               reg[i] = gethex (4, linebuf + 34 + 5 * i, &gottok);
1068             }
1069         }
1070     }
1071   while (!gottok);
1072   for (i = 0; i < NUM_REGS; i++)
1073     {
1074       char swapped[2];
1075
1076       swapped[1] = reg[i];
1077       swapped[0] = (reg[i]) >> 8;
1078
1079       supply_register (i, swapped);
1080     }
1081 }
1082 #endif
1083 /* Store register REGNO, or all if REGNO == -1.
1084    Return errno value.  */
1085 static void
1086 hms_store_register (regno)
1087      int regno;
1088 {
1089   if (regno == -1)
1090     {
1091       for (regno = 0; regno < NUM_REGS; regno++)
1092         {
1093           hms_store_register (regno);
1094         }
1095     }
1096   else
1097     {
1098       char *name = get_reg_name (regno);
1099       char buffer[100];
1100       /* Some regs dont really exist */
1101       if (!(name[0] == 'p' && name[1] == 'r')
1102           && !(name[0] == 'c' && name[1] == 'y')
1103           && !(name[0] == 't' && name[1] == 'i')
1104           && !(name[0] == 'i' && name[1] == 'n'))
1105         {
1106           sprintf (buffer, "r %s=%x", name, read_register (regno));
1107           hms_write_cr (buffer);
1108           expect_prompt ();
1109         }
1110     }
1111 }
1112
1113
1114 /* Get ready to modify the registers array.  On machines which store
1115    individual registers, this doesn't need to do anything.  On machines
1116    which store all the registers in one fell swoop, this makes sure
1117    that registers contains all the registers from the program being
1118    debugged.  */
1119
1120 void
1121 hms_prepare_to_store ()
1122 {
1123   /* Do nothing, since we can store individual regs */
1124 }
1125
1126 static CORE_ADDR
1127 translate_addr (addr)
1128      CORE_ADDR addr;
1129 {
1130
1131   return (addr);
1132
1133 }
1134
1135 /* Read a word from remote address ADDR and return it.
1136  * This goes through the data cache.
1137  */
1138 int
1139 hms_fetch_word (addr)
1140      CORE_ADDR addr;
1141 {
1142   return dcache_fetch (addr);
1143 }
1144
1145 /* Write a word WORD into remote address ADDR.
1146    This goes through the data cache.  */
1147
1148 void
1149 hms_store_word (addr, word)
1150      CORE_ADDR addr;
1151      int word;
1152 {
1153   dcache_poke (addr, word);
1154 }
1155
1156 int
1157 hms_xfer_inferior_memory (memaddr, myaddr, len, write, target)
1158      CORE_ADDR memaddr;
1159      char *myaddr;
1160      int len;
1161      int write;
1162      struct target_ops *target; /* ignored */
1163 {
1164   register int i;
1165
1166   /* Round starting address down to longword boundary.  */
1167   register CORE_ADDR addr;
1168
1169   /* Round ending address up; get number of longwords that makes.  */
1170   register int count;
1171
1172   /* Allocate buffer of that many longwords.  */
1173   register int *buffer;
1174
1175   memaddr &= 0xffff;
1176   addr = memaddr & -sizeof (int);
1177   count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
1178
1179   buffer = (int *) alloca (count * sizeof (int));
1180
1181   if (write)
1182     {
1183       /* Fill start and end extra bytes of buffer with existing memory data.  */
1184
1185       if (addr != memaddr || len < (int) sizeof (int))
1186         {
1187           /* Need part of initial word -- fetch it.  */
1188           buffer[0] = hms_fetch_word (addr);
1189         }
1190
1191       if (count > 1)            /* FIXME, avoid if even boundary */
1192         {
1193           buffer[count - 1]
1194             = hms_fetch_word (addr + (count - 1) * sizeof (int));
1195         }
1196
1197       /* Copy data to be written over corresponding part of buffer */
1198
1199       memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
1200
1201       /* Write the entire buffer.  */
1202
1203       for (i = 0; i < count; i++, addr += sizeof (int))
1204         {
1205           errno = 0;
1206           hms_store_word (addr, buffer[i]);
1207           if (errno)
1208             {
1209               return 0;
1210             }
1211
1212         }
1213     }
1214   else
1215     {
1216       /* Read all the longwords */
1217       for (i = 0; i < count; i++, addr += sizeof (int))
1218         {
1219           errno = 0;
1220           buffer[i] = hms_fetch_word (addr);
1221           if (errno)
1222             {
1223               return 0;
1224             }
1225           QUIT;
1226         }
1227
1228       /* Copy appropriate bytes out of the buffer.  */
1229       memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
1230     }
1231
1232   return len;
1233 }
1234
1235 int
1236 hms_write_inferior_memory (memaddr, myaddr, len)
1237      CORE_ADDR memaddr;
1238      unsigned char *myaddr;
1239      int len;
1240 {
1241   bfd_vma addr;
1242   int done;
1243   int todo;
1244   char buffer[100];
1245   done = 0;
1246   hms_write_cr (".");
1247   expect_prompt ();
1248   while (done < len)
1249     {
1250       char *ptr = buffer;
1251       int thisgo;
1252       int idx;
1253
1254       thisgo = len - done;
1255       if (thisgo > 20)
1256         thisgo = 20;
1257
1258       sprintf (ptr, "M.B %4x =", memaddr + done);
1259       ptr += 10;
1260       for (idx = 0; idx < thisgo; idx++)
1261         {
1262           sprintf (ptr, "%2x ", myaddr[idx + done]);
1263           ptr += 3;
1264         }
1265       hms_write_cr (buffer);
1266       expect_prompt ();
1267       done += thisgo;
1268     }
1269 }
1270
1271 void
1272 hms_files_info ()
1273 {
1274   char *file = "nothing";
1275
1276   if (exec_bfd)
1277     file = bfd_get_filename (exec_bfd);
1278
1279   if (exec_bfd)
1280 #ifdef __GO32__
1281     printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file);
1282 #else
1283     printf_filtered ("\tAttached to %s at %d baud and running program %s\n", dev_name, baudrate, file);
1284 #endif
1285   printf_filtered ("\ton an H8/300 processor.\n");
1286 }
1287
1288 /* Copy LEN bytes of data from debugger memory at MYADDR
1289    to inferior's memory at MEMADDR.  Returns errno value.
1290  * sb/sh instructions don't work on unaligned addresses, when TU=1.
1291  */
1292
1293 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
1294    at debugger address MYADDR.  Returns errno value.  */
1295 int
1296 hms_read_inferior_memory (memaddr, myaddr, len)
1297      CORE_ADDR memaddr;
1298      char *myaddr;
1299      int len;
1300 {
1301   /* Align to nearest low 16 bits */
1302   int i;
1303
1304   CORE_ADDR start = memaddr;
1305   CORE_ADDR end = memaddr + len - 1;
1306
1307   int ok = 1;
1308
1309   /*
1310     AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
1311     012345678901234567890123456789012345678901234567890123456789012345
1312     0         1         2         3         4         5         6
1313     */
1314   char buffer[66];
1315
1316   if (memaddr & 0xf)
1317     abort ();
1318   if (len != 16)
1319     abort ();
1320
1321   sprintf (buffer, "m %4x %4x", start & 0xffff, end & 0xffff);
1322   hms_write_cr (buffer);
1323   /* drop the echo and newline*/
1324   for (i = 0; i < 13; i++)
1325     readchar ();
1326
1327   /* Grab the lines as they come out and fill the area */
1328   /* Skip over cr */
1329   while (1)
1330     {
1331       int p;
1332       int i;
1333       int addr;
1334       size_t idx;
1335
1336       char byte[16];
1337
1338       buffer[0] = readchar ();
1339       if (buffer[0] == 'M')
1340         break;
1341       for (i = 1; i < 66; i++)
1342         buffer[i] = readchar ();
1343
1344       /* Now parse the line */
1345
1346       addr = gethex (4, buffer, &ok);
1347       idx = 6;
1348       for (p = 0; p < 16; p += 2)
1349         {
1350           byte[p] = gethex (2, buffer + idx, &ok);
1351           byte[p + 1] = gethex (2, buffer + idx + 2, &ok);
1352           idx += 5;
1353
1354         }
1355
1356       for (p = 0; p < 16; p++)
1357         {
1358           if (addr + p >= memaddr &&
1359               addr + p < memaddr + len)
1360             {
1361               myaddr[(addr + p) - memaddr] = byte[p];
1362
1363             }
1364
1365         }
1366     }
1367 #ifdef GDB_TARGET_IS_H8500
1368   expect ("ore>");
1369 #endif
1370 #ifdef GDB_TARGET_IS_H8300
1371   expect ("emory>");
1372 #endif
1373   hms_write_cr (".");
1374
1375   expect_prompt ();
1376   return len;
1377 }
1378
1379
1380
1381 #define MAX_BREAKS      16
1382 static int num_brkpts = 0;
1383 static int
1384 hms_insert_breakpoint (addr, save)
1385      CORE_ADDR addr;
1386      char *save;                /* Throw away, let hms save instructions */
1387 {
1388   check_open ();
1389
1390   if (num_brkpts < MAX_BREAKS)
1391     {
1392       char buffer[100];
1393
1394       num_brkpts++;
1395       sprintf (buffer, "b %x", addr & 0xffff);
1396       hms_write_cr (buffer);
1397       expect_prompt ();
1398       return (0);
1399     }
1400   else
1401     {
1402       fprintf_filtered (gdb_stderr,
1403                       "Too many break points, break point not installed\n");
1404       return (1);
1405     }
1406
1407 }
1408 static int
1409 hms_remove_breakpoint (addr, save)
1410      CORE_ADDR addr;
1411      char *save;                /* Throw away, let hms save instructions */
1412 {
1413   if (num_brkpts > 0)
1414     {
1415       char buffer[100];
1416
1417       num_brkpts--;
1418       sprintf (buffer, "b - %x", addr & 0xffff);
1419       hms_write_cr (buffer);
1420       expect_prompt ();
1421
1422     }
1423   return (0);
1424 }
1425
1426 /* Clear the hmss notion of what the break points are */
1427 static int
1428 hms_clear_breakpoints ()
1429 {
1430
1431   if (is_open)
1432     {
1433       hms_write_cr ("b -");
1434       expect_prompt ();
1435     }
1436   num_brkpts = 0;
1437 }
1438 static void
1439 hms_mourn ()
1440 {
1441   hms_clear_breakpoints ();
1442   unpush_target (&hms_ops);
1443   generic_mourn_inferior ();
1444 }
1445
1446 /* Put a command string, in args, out to the hms.  The hms is assumed to
1447    be in raw mode, all writing/reading done through desc.
1448    Ouput from the hms is placed on the users terminal until the
1449    prompt from the hms is seen.
1450    FIXME: Can't handle commands that take input.  */
1451
1452 void
1453 hms_com (args, fromtty)
1454      char *args;
1455      int fromtty;
1456 {
1457   check_open ();
1458
1459   if (!args)
1460     return;
1461
1462   /* Clear all input so only command relative output is displayed */
1463
1464   hms_write_cr (args);
1465 /*  hms_write ("\030", 1);*/
1466   expect_prompt ();
1467 }
1468
1469 /* Define the target subroutine names */
1470
1471 struct target_ops hms_ops =
1472 {
1473   "hms", "Remote HMS monitor",
1474   "Use the H8 evaluation board running the HMS monitor connected\n\
1475 by a serial line.",
1476
1477   hms_open, hms_close,
1478   0, hms_detach, hms_resume, hms_wait,  /* attach */
1479   hms_fetch_register, hms_store_register,
1480   hms_prepare_to_store,
1481   hms_xfer_inferior_memory,
1482   hms_files_info,
1483   hms_insert_breakpoint, hms_remove_breakpoint, /* Breakpoints */
1484   0, 0, 0, 0, 0,                /* Terminal handling */
1485   hms_kill,                     /* FIXME, kill */
1486   hms_load,
1487   0,                            /* lookup_symbol */
1488   hms_create_inferior,          /* create_inferior */
1489   hms_mourn,                    /* mourn_inferior FIXME */
1490   0,                            /* can_run */
1491   0,                            /* notice_signals */
1492   process_stratum, 0,           /* next */
1493   1, 1, 1, 1, 1,                /* all mem, mem, stack, regs, exec */
1494   0, 0,                         /* Section pointers */
1495   OPS_MAGIC,                    /* Always the last thing */
1496 };
1497
1498 hms_quiet ()
1499 {
1500   quiet = !quiet;
1501   if (quiet)
1502     printf_filtered ("Snoop disabled\n");
1503   else
1504     printf_filtered ("Snoop enabled\n");
1505
1506 }
1507
1508 hms_device (s)
1509      char *s;
1510 {
1511   if (s)
1512     {
1513       dev_name = get_word (&s);
1514     }
1515 }
1516
1517 static
1518 hms_speed (s)
1519      char *s;
1520 {
1521   check_open ();
1522
1523   if (s)
1524     {
1525       char buffer[100];
1526       int newrate = atoi (s);
1527       int which = 0;
1528
1529       if (SERIAL_SETBAUDRATE (desc, newrate))
1530         error ("Can't use %d baud\n", newrate);
1531
1532       printf_filtered ("Checking target is in sync\n");
1533
1534       printf_filtered ("Sending commands to set target to %d\n",
1535                        baudrate);
1536
1537       sprintf (buffer, "tm %d. N 8 1", baudrate);
1538       hms_write_cr (buffer);
1539     }
1540 }
1541
1542 /***********************************************************************/
1543
1544 static void
1545 hms_drain (args, fromtty)
1546      char *args;
1547      int fromtty;
1548
1549 {
1550   int c;
1551   while (1)
1552     {
1553       c = SERIAL_READCHAR (desc, 1);
1554       if (c == SERIAL_TIMEOUT)
1555         break;
1556       if (c == SERIAL_ERROR)
1557         break;
1558       if (c > ' ' && c < 127)
1559         printf ("%c", c & 0xff);
1560       else
1561         printf ("<%x>", c & 0xff);
1562     }
1563 }
1564
1565 static void
1566 add_commands ()
1567 {
1568
1569   add_com ("hmsdrain", class_obscure, hms_drain,
1570            "Drain pending hms text buffers.");
1571 }
1572
1573 static void
1574 remove_commands ()
1575 {
1576   extern struct cmd_list_element *cmdlist;
1577   delete_cmd ("hms-drain", &cmdlist);
1578 }
1579
1580 void
1581 _initialize_remote_hms ()
1582 {
1583   add_target (&hms_ops);
1584
1585   add_com ("hms <command>", class_obscure, hms_com,
1586            "Send a command to the HMS monitor.");
1587   add_com ("snoop", class_obscure, hms_quiet,
1588            "Show what commands are going to the monitor");
1589
1590   add_com ("device", class_obscure, hms_device,
1591            "Set the terminal line for HMS communications");
1592
1593   add_com ("speed", class_obscure, hms_speed,
1594            "Set the terminal line speed for HMS communications");
1595
1596   dev_name = NULL;
1597 }