gdb/remote-hms.c

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