gdb/remote-os9k.c

   1  /* Remote debugging interface for boot monitors, for GDB.
   2    Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* This file was derived from remote-eb.c, which did a similar job, but for
  21    an AMD-29K running EBMON.  That file was in turn derived from remote.c
  22    as mentioned in the following comment (left in for comic relief):
  23
  24   "This is like remote.c but is for a different situation--
  25    having a PC running os9000 hook up with a unix machine with
  26    a serial line, and running ctty com2 on the PC. os9000 has a debug
  27    monitor called ROMBUG running.  Not to mention that the PC
  28    has PC/NFS, so it can access the same executables that gdb can,
  29    over the net in real time."
  30
  31    In reality, this module talks to a debug monitor called 'ROMBUG', which
  32    We communicate with ROMBUG via a direct serial line, the network version
  33    of ROMBUG is not available yet.
  34 */
  35
  36 #include "defs.h"
  37 #include "gdbcore.h"
  38 #include "target.h"
  39 #include "wait.h"
  40 #include <varargs.h>
  41 #include <signal.h>
  42 #include <string.h>
  43 #include <sys/types.h>
  44 #include "command.h"
  45 #include "serial.h"
  46 #include "monitor.h"
  47 #include "remote-utils.h"
  48 #include "symtab.h"
  49 #include "symfile.h"
  50 #include "objfiles.h"
  51 #include "gdb-stabs.h"
  52
  53 #ifdef HAVE_TERMIO
  54 #  define TERMINAL struct termios
  55 #else
  56 #  define TERMINAL struct sgttyb
  57 #endif
  58
  59 struct monitor_ops *current_monitor;
  60 struct cmd_list_element *showlist;
  61 extern struct target_ops rombug_ops;            /* Forward declaration */
  62 extern struct monitor_ops rombug_cmds;          /* Forward declaration */
  63 extern struct cmd_list_element *setlist;
  64 extern struct cmd_list_element *unsetlist;
  65 extern int attach_flag;
  66
  67 static void rombug_close();
  68 static void rombug_fetch_register();
  69 static void rombug_fetch_registers();
  70 static void rombug_store_register();
  71 #if 0
  72 static int sr_get_debug();                      /* flag set by "set remotedebug" */
  73 #endif
  74 static int hashmark;                            /* flag set by "set hash" */
  75 static int rombug_is_open = 0;
  76
  77 /* FIXME: Replace with sr_get_debug ().  */
  78 #define LOG_FILE "monitor.log"
  79 #if defined (LOG_FILE)
  80 FILE *log_file;
  81 #endif
  82
  83 static int timeout = 5;
  84 static int is_trace_mode = 0;
  85 /* Descriptor for I/O to remote machine.  Initialize it to NULL*/
  86 static serial_t monitor_desc = NULL;
  87
  88 /* Send data to monitor.  Works just like printf. */
  89 static void
  90 printf_monitor(va_alist)
  91      va_dcl
  92 {
  93   va_list args;
  94   char *pattern;
  95   char buf[200];
  96   int i;
  97
  98   va_start(args);
  99
 100   pattern = va_arg(args, char *);
 101
 102   vsprintf(buf, pattern, args);
 103
 104   if (SERIAL_WRITE(monitor_desc, buf, strlen(buf)))
 105     fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno));
 106 }
 107
 108 /* Read a character from the remote system, doing all the fancy timeout stuff*/
 109 static int
 110 readchar(timeout)
 111      int timeout;
 112 {
 113   int c;
 114
 115   c = SERIAL_READCHAR(monitor_desc, timeout);
 116
 117   if (sr_get_debug())
 118     putchar(c & 0x7f);
 119
 120 #ifdef LOG_FILE
 121   if (isascii (c))
 122     putc(c & 0x7f, log_file);
 123 #endif
 124
 125   if (c >= 0)
 126     return c & 0x7f;
 127
 128   if (c == SERIAL_TIMEOUT)
 129     {
 130       if (timeout == 0)
 131         return c;               /* Polls shouldn't generate timeout errors */
 132
 133       error("Timeout reading from remote system.");
 134     }
 135
 136   perror_with_name("remote-monitor");
 137 }
 138
 139 /* Scan input from the remote system, until STRING is found.  If DISCARD is
 140    non-zero, then discard non-matching input, else print it out.
 141    Let the user break out immediately.  */
 142 static void
 143 expect(string, discard)
 144      char *string;
 145      int discard;
 146 {
 147   char *p = string;
 148   int c;
 149
 150   if (sr_get_debug())
 151     printf ("Expecting \"%s\"\n", string);
 152
 153   immediate_quit = 1;
 154   while (1)
 155     {
 156       c = readchar(timeout);
 157       if (!isascii (c))
 158         continue;
 159       if (c == *p++)
 160         {
 161           if (*p == '\0')
 162             {
 163               immediate_quit = 0;
 164               if (sr_get_debug())
 165                 printf ("\nMatched\n");
 166               return;
 167             }
 168         }
 169       else
 170         {
 171           if (!discard)
 172             {
 173               fwrite(string, 1, (p - 1) - string, stdout);
 174               putchar((char)c);
 175               fflush(stdout);
 176             }
 177           p = string;
 178         }
 179     }
 180 }
 181
 182 /* Keep discarding input until we see the ROMBUG prompt.
 183
 184    The convention for dealing with the prompt is that you
 185    o give your command
 186    o *then* wait for the prompt.
 187
 188    Thus the last thing that a procedure does with the serial line
 189    will be an expect_prompt().  Exception:  rombug_resume does not
 190    wait for the prompt, because the terminal is being handed over
 191    to the inferior.  However, the next thing which happens after that
 192    is a rombug_wait which does wait for the prompt.
 193    Note that this includes abnormal exit, e.g. error().  This is
 194    necessary to prevent getting into states from which we can't
 195    recover.  */
 196 static void
 197 expect_prompt(discard)
 198      int discard;
 199 {
 200 #if defined (LOG_FILE)
 201   /* This is a convenient place to do this.  The idea is to do it often
 202      enough that we never lose much data if we terminate abnormally.  */
 203   fflush(log_file);
 204 #endif
 205   if (is_trace_mode) {
 206     expect("trace", discard);
 207     is_trace_mode = 0;
 208   } else {
 209     expect (PROMPT, discard);
 210   }
 211 }
 212
 213 /* Get a hex digit from the remote system & return its value.
 214    If ignore_space is nonzero, ignore spaces (not newline, tab, etc).  */
 215 static int
 216 get_hex_digit(ignore_space)
 217      int ignore_space;
 218 {
 219   int ch;
 220   while (1)
 221     {
 222       ch = readchar(timeout);
 223       if (ch >= '0' && ch <= '9')
 224         return ch - '0';
 225       else if (ch >= 'A' && ch <= 'F')
 226         return ch - 'A' + 10;
 227       else if (ch >= 'a' && ch <= 'f')
 228         return ch - 'a' + 10;
 229       else if (ch == ' ' && ignore_space)
 230         ;
 231       else
 232         {
 233           expect_prompt(1);
 234           error("Invalid hex digit from remote system.");
 235         }
 236     }
 237 }
 238
 239 /* Get a byte from monitor and put it in *BYT.  Accept any number
 240    leading spaces.  */
 241 static void
 242 get_hex_byte (byt)
 243      char *byt;
 244 {
 245   int val;
 246
 247   val = get_hex_digit (1) << 4;
 248   val |= get_hex_digit (0);
 249   *byt = val;
 250 }
 251
 252 /* Get N 32-bit words from remote, each preceded by a space,
 253    and put them in registers starting at REGNO.  */
 254 static void
 255 get_hex_regs (n, regno)
 256      int n;
 257      int regno;
 258 {
 259   long val;
 260   int i;
 261   unsigned char b;
 262
 263   for (i = 0; i < n; i++)
 264     {
 265       int j;
 266
 267       val = 0;
 268       for (j = 0; j < 4; j++)
 269         {
 270 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 271           get_hex_byte(&b);
 272           val = (val << 8) + b;
 273 #else
 274           get_hex_byte(&b);
 275           val = val + (b << (j*8));
 276 #endif
 277         }
 278       supply_register (regno++, (char *) &val);
 279     }
 280 }
 281
 282 /* This is called not only when we first attach, but also when the
 283    user types "run" after having attached.  */
 284 static void
 285 rombug_create_inferior (execfile, args, env)
 286      char *execfile;
 287      char *args;
 288      char **env;
 289 {
 290   int entry_pt;
 291
 292   /* Nonzero value indicates that a process really is running.  */
 293   inferior_pid = 42;
 294
 295   if (args && *args)
 296     error("Can't pass arguments to remote ROMBUG process");
 297
 298   if (execfile == 0 || exec_bfd == 0)
 299     error("No exec file specified");
 300
 301   entry_pt = (int) bfd_get_start_address (exec_bfd);
 302
 303 #ifdef LOG_FILE
 304   fputs ("\nIn Create_inferior()", log_file);
 305 #endif
 306
 307 /* The "process" (board) is already stopped awaiting our commands, and
 308    the program is already downloaded.  We just set its PC and go.  */
 309
 310   init_wait_for_inferior ();
 311   proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
 312 }
 313
 314 /* Open a connection to a remote debugger.
 315    NAME is the filename used for communication.  */
 316
 317 static int baudrate = 9600;
 318 static char dev_name[100];
 319
 320 static void
 321 rombug_open(args, from_tty)
 322      char *args;
 323      int from_tty;
 324 {
 325   if (args == NULL)
 326     error ("Use `target RomBug DEVICE-NAME' to use a serial port, or \n\
 327 `target RomBug HOST-NAME:PORT-NUMBER' to use a network connection.");
 328
 329   target_preopen(from_tty);
 330
 331   if (rombug_is_open)
 332     unpush_target(&rombug_ops);
 333
 334   strcpy(dev_name, args);
 335   monitor_desc = SERIAL_OPEN(dev_name);
 336   if (monitor_desc == NULL)
 337     perror_with_name(dev_name);
 338
 339   /* The baud rate was specified when GDB was started. ***
 340   if (SERIAL_SETBAUDRATE (monitor_desc, sr_get_baud_rate()))
 341     {
 342       SERIAL_CLOSE (monitor_desc);
 343       perror_with_name ("RomBug");
 344     }
 345   */
 346   SERIAL_RAW(monitor_desc);
 347   rombug_is_open = 1;
 348
 349 #if defined (LOG_FILE)
 350   log_file = fopen (LOG_FILE, "w");
 351   if (log_file == NULL)
 352     perror_with_name (LOG_FILE);
 353 #endif
 354
 355   push_monitor (&rombug_cmds);
 356
 357   printf_monitor("\r"); /* CR wakes up monitor */
 358   expect_prompt(1);
 359
 360   push_target (&rombug_ops);
 361   if (from_tty)
 362     printf("Remote %s connected to %s\n", target_shortname,
 363            dev_name);
 364
 365   attach_flag = 1;
 366   rombug_fetch_registers();
 367 }
 368
 369 /*
 370  * Close out all files and local state before this target loses control.
 371  */
 372
 373 static void
 374 rombug_close (quitting)
 375      int quitting;
 376 {
 377   if (rombug_is_open) {
 378     SERIAL_CLOSE(monitor_desc);
 379     monitor_desc = NULL;
 380     rombug_is_open = 0;
 381   }
 382
 383 #if defined (LOG_FILE)
 384   if (log_file) {
 385     if (ferror(log_file))
 386       fprintf(stderr, "Error writing log file.\n");
 387     if (fclose(log_file) != 0)
 388       fprintf(stderr, "Error closing log file.\n");
 389     log_file = 0;
 390   }
 391 #endif
 392 }
 393
 394 int
 395 rombug_link(mod_name, text_reloc)
 396      char *mod_name;
 397      CORE_ADDR *text_reloc;
 398 {
 399   int i, j;
 400   unsigned long val;
 401   unsigned char b;
 402
 403   printf_monitor("l %s \r", mod_name);
 404   expect_prompt(1);
 405   printf_monitor(".r \r");
 406   expect(REG_DELIM, 1);
 407   for (i=0; i <= 7; i++)
 408     {
 409       val = 0;
 410       for (j = 0; j < 4; j++)
 411         {
 412           get_hex_byte(&b);
 413           val = (val << 8) + b;
 414         }
 415     }
 416   expect_prompt(1);
 417   *text_reloc = val;
 418   return 1;
 419 }
 420
 421 /* Terminate the open connection to the remote debugger.
 422    Use this when you want to detach and do something else
 423    with your gdb.  */
 424 static void
 425 rombug_detach (from_tty)
 426      int from_tty;
 427 {
 428   if (attach_flag) {
 429     printf_monitor (GO_CMD);
 430     attach_flag = 0;
 431   }
 432   pop_target();         /* calls rombug_close to do the real work */
 433   if (from_tty)
 434     printf ("Ending remote %s debugging\n", target_shortname);
 435 }
 436
 437 /*
 438  * Tell the remote machine to resume.
 439  */
 440 static void
 441 rombug_resume (pid, step, sig)
 442      int pid, step;
 443      enum target_signal sig;
 444 {
 445 #ifdef LOG_FILE
 446   fprintf (log_file, "\nIn Resume (step=%d, sig=%d)\n", step, sig);
 447 #endif
 448
 449   if (step)
 450     {
 451       is_trace_mode = 1;
 452       printf_monitor (STEP_CMD);
 453       /* wait for the echo.  */
 454       expect (STEP_CMD, 1);
 455     }
 456   else
 457     {
 458       printf_monitor (GO_CMD);
 459       /* swallow the echo.  */
 460       expect (GO_CMD, 1);
 461     }
 462 }
 463
 464 /*
 465  * Wait until the remote machine stops, then return,
 466  * storing status in status just as `wait' would.
 467  */
 468
 469 static int
 470 rombug_wait (pid, status)
 471      int pid;
 472      struct target_waitstatus *status;
 473 {
 474   int old_timeout = timeout;
 475   struct section_offsets *offs;
 476   CORE_ADDR addr, pc;
 477   struct obj_section *obj_sec;
 478
 479 #ifdef LOG_FILE
 480   fputs ("\nIn wait ()", log_file);
 481 #endif
 482
 483   status->kind = TARGET_WAITKIND_EXITED;
 484   status->value.integer = 0;
 485
 486   timeout = 0;          /* Don't time out -- user program is running. */
 487   expect_prompt(1);     /* Wait for prompt, outputting extraneous text */
 488
 489   status->kind = TARGET_WAITKIND_STOPPED;
 490   status->value.sig = TARGET_SIGNAL_TRAP;
 491   timeout = old_timeout;
 492   rombug_fetch_registers();
 493   pc = read_register(PC_REGNUM);
 494   addr = read_register(DATABASE_REG);
 495
 496   obj_sec = find_pc_section (pc);
 497   if (obj_sec != NULL)
 498     new_symfile_objfile (obj_sec, 1, 0);
 499
 500   offs = ((struct section_offsets *)
 501          alloca (sizeof (struct section_offsets)
 502          + (symfile_objfile->num_sections * sizeof (offs->offsets))));
 503   memcpy (offs, symfile_objfile->section_offsets,
 504          (sizeof (struct section_offsets) +
 505          (symfile_objfile->num_sections * sizeof (offs->offsets))));
 506   ANOFFSET (offs, SECT_OFF_DATA) = addr;
 507   ANOFFSET (offs, SECT_OFF_BSS) = addr;
 508
 509   /* Because we only set offsets for DATA and BSS sections, and the other
 510      offsets are unchanged from ->section_offsets, the other sections won't
 511      get relocated.  */
 512   objfile_relocate (symfile_objfile, offs);
 513
 514   return 0;
 515 }
 516
 517 /* Return the name of register number regno in the form input and output by
 518    monitor.  Currently, register_names just happens to contain exactly what
 519    monitor wants.  Lets take advantage of that just as long as possible! */
 520
 521 static char *
 522 get_reg_name (regno)
 523      int regno;
 524 {
 525   static char buf[50];
 526   char *p;
 527   char *b;
 528
 529   b = buf;
 530
 531   if (regno < 0)
 532     return ("");
 533 /*
 534   for (p = reg_names[regno]; *p; p++)
 535     *b++ = toupper(*p);
 536   *b = '\000';
 537 */
 538   p = (char *)reg_names[regno];
 539   return p;
 540 /*
 541   return buf;
 542 */
 543 }
 544
 545 /* read the remote registers into the block regs.  */
 546
 547 static void
 548 rombug_fetch_registers ()
 549 {
 550   int regno, j, i;
 551   long val;
 552   unsigned char b;
 553
 554   printf_monitor (GET_REG);
 555   expect("eax:", 1);
 556   expect("\n", 1);
 557   get_hex_regs(1, 0);
 558   get_hex_regs(1, 3);
 559   get_hex_regs(1, 1);
 560   get_hex_regs(1, 2);
 561   get_hex_regs(1, 6);
 562   get_hex_regs(1, 7);
 563   get_hex_regs(1, 5);
 564   get_hex_regs(1, 4);
 565   for (regno = 8; regno <= 15; regno++)
 566     {
 567       expect(REG_DELIM, 1);
 568       if (regno >= 8 && regno <= 13)
 569         {
 570           val = 0;
 571           for (j = 0; j < 2; j++)
 572             {
 573 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 574               get_hex_byte(&b);
 575               val = (val << 8) + b;
 576 #else
 577               get_hex_byte(&b);
 578               val = val + (b << (j*8));
 579 #endif
 580             }
 581
 582           if (regno == 8) i = 10;
 583           if (regno >=  9 && regno <= 12) i = regno + 3;
 584           if (regno == 13) i = 11;
 585           supply_register (i, (char *) &val);
 586         }
 587       else if (regno == 14)
 588         {
 589           get_hex_regs(1, PC_REGNUM);
 590         }
 591       else if (regno == 15)
 592         {
 593           get_hex_regs(1, 9);
 594         }
 595       else
 596         {
 597           val = 0;
 598           supply_register(regno, (char *) &val);
 599         }
 600     }
 601   expect_prompt (1);
 602 }
 603
 604 /* Fetch register REGNO, or all registers if REGNO is -1.
 605    Returns errno value.  */
 606 static void
 607 rombug_fetch_register (regno)
 608      int regno;
 609 {
 610   int val, j;
 611   unsigned char b;
 612
 613 #ifdef LOG_FILE
 614   fprintf (log_file, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno));
 615   fflush (log_file);
 616 #endif
 617
 618   if (regno < 0)
 619     {
 620       rombug_fetch_registers ();
 621     }
 622   else
 623     {
 624       char *name = get_reg_name (regno);
 625       printf_monitor (GET_REG);
 626       if (regno >= 10 && regno <= 15)
 627         {
 628           expect ("\n", 1);
 629           expect ("\n", 1);
 630           expect (name, 1);
 631           expect (REG_DELIM, 1);
 632           val = 0;
 633           for (j = 0; j < 2; j++)
 634             {
 635 #if TARGET_BYTE_ORDER == BIG_ENDIAN
 636               get_hex_byte(&b);
 637               val = (val << 8) + b;
 638 #else
 639               get_hex_byte(&b);
 640               val = val + (b << (j*8));
 641 #endif
 642             }
 643           supply_register (regno, (char *) &val);
 644         }
 645       else if (regno == 8 || regno == 9)
 646         {
 647           expect ("\n", 1);
 648           expect ("\n", 1);
 649           expect ("\n", 1);
 650           expect (name, 1);
 651           expect (REG_DELIM, 1);
 652           get_hex_regs (1, regno);
 653         }
 654       else
 655         {
 656           expect (name, 1);
 657           expect (REG_DELIM, 1);
 658           expect("\n", 1);
 659           get_hex_regs(1, 0);
 660           get_hex_regs(1, 3);
 661           get_hex_regs(1, 1);
 662           get_hex_regs(1, 2);
 663           get_hex_regs(1, 6);
 664           get_hex_regs(1, 7);
 665           get_hex_regs(1, 5);
 666           get_hex_regs(1, 4);
 667         }
 668       expect_prompt (1);
 669     }
 670   return;
 671 }
 672
 673 /* Store the remote registers from the contents of the block REGS.  */
 674
 675 static void
 676 rombug_store_registers ()
 677 {
 678   int regno;
 679
 680   for (regno = 0; regno <= PC_REGNUM; regno++)
 681     rombug_store_register(regno);
 682
 683   registers_changed ();
 684 }
 685
 686 /* Store register REGNO, or all if REGNO == 0.
 687    return errno value.  */
 688 static void
 689 rombug_store_register (regno)
 690      int regno;
 691 {
 692 char *name;
 693
 694 #ifdef LOG_FILE
 695   fprintf (log_file, "\nIn Store_register (regno=%d)\n", regno);
 696 #endif
 697   if (regno == -1)
 698     rombug_store_registers ();
 699   else
 700     {
 701       if (sr_get_debug())
 702         printf ("Setting register %s to 0x%x\n", get_reg_name (regno), read_register (regno));
 703
 704       name = get_reg_name(regno);
 705       if (name == 0) return;
 706       printf_monitor (SET_REG, name, read_register (regno));
 707
 708       expect_prompt (1);
 709     }
 710 }
 711
 712 /* Get ready to modify the registers array.  On machines which store
 713    individual registers, this doesn't need to do anything.  On machines
 714    which store all the registers in one fell swoop, this makes sure
 715    that registers contains all the registers from the program being
 716    debugged.  */
 717
 718 static void
 719 rombug_prepare_to_store ()
 720 {
 721   /* Do nothing, since we can store individual regs */
 722 }
 723
 724 static void
 725 rombug_files_info ()
 726 {
 727   printf ("\tAttached to %s at %d baud.\n",
 728           dev_name, baudrate);
 729 }
 730
 731 /* Copy LEN bytes of data from debugger memory at MYADDR
 732    to inferior's memory at MEMADDR.  Returns length moved.  */
 733 static int
 734 rombug_write_inferior_memory (memaddr, myaddr, len)
 735      CORE_ADDR memaddr;
 736      unsigned char *myaddr;
 737      int len;
 738 {
 739   int i;
 740   char buf[10];
 741
 742 #ifdef LOG_FILE
 743   fprintf (log_file, "\nIn Write_inferior_memory (memaddr=%x, len=%d)\n", memaddr, len);
 744 #endif
 745   printf_monitor (MEM_SET_CMD, memaddr + i);
 746   for (i = 0; i < len; i++)
 747     {
 748       expect (CMD_DELIM, 1);
 749       printf_monitor ("%x", myaddr[i]);
 750       if (sr_get_debug())
 751         printf ("\nSet 0x%x to 0x%x\n", memaddr + i, myaddr[i]);
 752     }
 753   if (CMD_END)
 754     printf_monitor (CMD_END);
 755   expect_prompt (1);
 756
 757   return len;
 758 }
 759
 760 /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
 761    at debugger address MYADDR.  Returns length moved.  */
 762 static int
 763 rombug_read_inferior_memory(memaddr, myaddr, len)
 764      CORE_ADDR memaddr;
 765      char *myaddr;
 766      int len;
 767 {
 768   int i, j;
 769   char buf[20];
 770
 771   /* Number of bytes read so far.  */
 772   int count;
 773
 774   /* Starting address of this pass.  */
 775   unsigned long startaddr;
 776
 777   /* Number of bytes to read in this pass.  */
 778   int len_this_pass;
 779
 780 #ifdef LOG_FILE
 781   fprintf (log_file, "\nIn Read_inferior_memory (memaddr=%x, len=%d)\n", memaddr, len);
 782 #endif
 783
 784   /* Note that this code works correctly if startaddr is just less
 785      than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
 786      thing).  That is, something like
 787      rombug_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
 788      works--it never adds len To memaddr and gets 0.  */
 789   /* However, something like
 790      rombug_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
 791      doesn't need to work.  Detect it and give up if there's an attempt
 792      to do that.  */
 793   if (((memaddr - 1) + len) < memaddr) {
 794     errno = EIO;
 795     return 0;
 796   }
 797
 798   startaddr = memaddr;
 799   count = 0;
 800   while (count < len)
 801     {
 802       len_this_pass = 16;
 803       if ((startaddr % 16) != 0)
 804         len_this_pass -= startaddr % 16;
 805       if (len_this_pass > (len - count))
 806         len_this_pass = (len - count);
 807       if (sr_get_debug())
 808         printf ("\nDisplay %d bytes at %x\n", len_this_pass, startaddr);
 809
 810       printf_monitor (MEM_DIS_CMD, startaddr, 16);
 811       expect ("- ", 1);
 812       for (i = 0; i < len_this_pass; i++)
 813         {
 814           get_hex_byte (&myaddr[count++]);
 815           if (sr_get_debug())
 816             printf ("\nRead a 0x%x from 0x%x\n", myaddr[count-1], startaddr);
 817           startaddr += 1;
 818         }
 819       expect(CMD_DELIM, 1);
 820     }
 821   if (CMD_END)
 822       printf_monitor (CMD_END);
 823   expect_prompt (1);
 824
 825   return len;
 826 }
 827
 828 /* FIXME-someday!  merge these two.  */
 829 static int
 830 rombug_xfer_inferior_memory (memaddr, myaddr, len, write, target)
 831      CORE_ADDR memaddr;
 832      char *myaddr;
 833      int len;
 834      int write;
 835      struct target_ops *target;         /* ignored */
 836 {
 837   if (write)
 838     return rombug_write_inferior_memory (memaddr, myaddr, len);
 839   else
 840     return rombug_read_inferior_memory (memaddr, myaddr, len);
 841 }
 842
 843 static void
 844 rombug_kill (args, from_tty)
 845      char *args;
 846      int from_tty;
 847 {
 848   return;               /* ignore attempts to kill target system */
 849 }
 850
 851 /* Clean up when a program exits.
 852    The program actually lives on in the remote processor's RAM, and may be
 853    run again without a download.  Don't leave it full of breakpoint
 854    instructions.  */
 855
 856 static void
 857 rombug_mourn_inferior ()
 858 {
 859   remove_breakpoints ();
 860   generic_mourn_inferior ();    /* Do all the proper things now */
 861 }
 862
 863 #define MAX_MONITOR_BREAKPOINTS 16
 864
 865 extern int memory_breakpoint_size;
 866 static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = {0};
 867
 868 static int
 869 rombug_insert_breakpoint (addr, shadow)
 870      CORE_ADDR addr;
 871      char *shadow;
 872 {
 873   int i;
 874
 875 #ifdef LOG_FILE
 876   fprintf (log_file, "\nIn Insert_breakpoint (addr=%x)\n", addr);
 877 #endif
 878   for (i = 0; i <= MAX_MONITOR_BREAKPOINTS; i++)
 879     if (breakaddr[i] == 0)
 880       {
 881         breakaddr[i] = addr;
 882         if (sr_get_debug())
 883           printf ("Breakpoint at %x\n", addr);
 884         rombug_read_inferior_memory(addr, shadow, memory_breakpoint_size);
 885         printf_monitor(SET_BREAK_CMD, addr);
 886         expect_prompt(1);
 887         return 0;
 888       }
 889
 890   fprintf(stderr, "Too many breakpoints (> 16) for monitor\n");
 891   return 1;
 892 }
 893
 894 /*
 895  * _remove_breakpoint -- Tell the monitor to remove a breakpoint
 896  */
 897 static int
 898 rombug_remove_breakpoint (addr, shadow)
 899      CORE_ADDR addr;
 900      char *shadow;
 901 {
 902   int i;
 903
 904 #ifdef LOG_FILE
 905   fprintf (log_file, "\nIn Remove_breakpoint (addr=%x)\n", addr);
 906 #endif
 907   for (i = 0; i < MAX_MONITOR_BREAKPOINTS; i++)
 908     if (breakaddr[i] == addr)
 909       {
 910         breakaddr[i] = 0;
 911         /* some monitors remove breakpoints based on the address */
 912         if (strcasecmp (target_shortname, "bug") == 0)
 913             printf_monitor(CLR_BREAK_CMD, addr);
 914           else
 915             printf_monitor(CLR_BREAK_CMD, i);
 916         expect_prompt(1);
 917         return 0;
 918       }
 919
 920   fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr);
 921   return 1;
 922 }
 923
 924 /* Load a file. This is usually an srecord, which is ascii. No
 925    protocol, just sent line by line. */
 926
 927 #define DOWNLOAD_LINE_SIZE 100
 928 static void
 929 rombug_load (arg)
 930     char        *arg;
 931 {
 932 /* this part comment out for os9* */
 933 #if 0
 934   FILE *download;
 935   char buf[DOWNLOAD_LINE_SIZE];
 936   int i, bytes_read;
 937
 938   if (sr_get_debug())
 939     printf ("Loading %s to monitor\n", arg);
 940
 941   download = fopen (arg, "r");
 942   if (download == NULL)
 943     {
 944     error (sprintf (buf, "%s Does not exist", arg));
 945     return;
 946   }
 947
 948   printf_monitor (LOAD_CMD);
 949 /*  expect ("Waiting for S-records from host... ", 1); */
 950
 951   while (!feof (download))
 952     {
 953       bytes_read = fread (buf, sizeof (char), DOWNLOAD_LINE_SIZE, download);
 954       if (hashmark)
 955         {
 956           putchar ('.');
 957           fflush (stdout);
 958         }
 959
 960       if (SERIAL_WRITE(monitor_desc, buf, bytes_read)) {
 961         fprintf(stderr, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno));
 962         break;
 963       }
 964       i = 0;
 965       while (i++ <=200000) {} ;                         /* Ugly HACK, probably needs flow control */
 966       if (bytes_read < DOWNLOAD_LINE_SIZE)
 967         {
 968           if (!feof (download))
 969             error ("Only read %d bytes\n", bytes_read);
 970           break;
 971         }
 972     }
 973
 974   if (hashmark)
 975     {
 976       putchar ('\n');
 977     }
 978   if (!feof (download))
 979     error ("Never got EOF while downloading");
 980   fclose (download);
 981 #endif 0
 982 }
 983
 984 /* Put a command string, in args, out to MONITOR.
 985    Output from MONITOR is placed on the users terminal until the prompt
 986    is seen. */
 987
 988 static void
 989 rombug_command (args, fromtty)
 990      char       *args;
 991      int        fromtty;
 992 {
 993 #ifdef LOG_FILE
 994   fprintf (log_file, "\nIn command (args=%s)\n", args);
 995 #endif
 996   if (monitor_desc == NULL)
 997     error("monitor target not open.");
 998
 999   if (!args)
1000     error("Missing command.");
1001
1002   printf_monitor("%s\r", args);
1003   expect_prompt(0);
1004 }
1005
1006 #if 0
1007 /* Connect the user directly to MONITOR.  This command acts just like the
1008    'cu' or 'tip' command.  Use <CR>~. or <CR>~^D to break out.  */
1009
1010 static struct ttystate ttystate;
1011
1012 static void
1013 cleanup_tty()
1014 {  printf("\r\n[Exiting connect mode]\r\n");
1015   /*SERIAL_RESTORE(0, &ttystate);*/
1016 }
1017
1018 static void
1019 connect_command (args, fromtty)
1020      char       *args;
1021      int        fromtty;
1022 {
1023   fd_set readfds;
1024   int numfds;
1025   int c;
1026   char cur_esc = 0;
1027
1028   dont_repeat();
1029
1030   if (monitor_desc == NULL)
1031     error("monitor target not open.");
1032
1033   if (args)
1034     fprintf("This command takes no args.  They have been ignored.\n");
1035
1036   printf("[Entering connect mode.  Use ~. or ~^D to escape]\n");
1037
1038   serial_raw(0, &ttystate);
1039
1040   make_cleanup(cleanup_tty, 0);
1041
1042   FD_ZERO(&readfds);
1043
1044   while (1)
1045     {
1046       do
1047         {
1048           FD_SET(0, &readfds);
1049           FD_SET(monitor_desc, &readfds);
1050           numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0);
1051         }
1052       while (numfds == 0);
1053
1054       if (numfds < 0)
1055         perror_with_name("select");
1056
1057       if (FD_ISSET(0, &readfds))
1058         {                       /* tty input, send to monitor */
1059           c = getchar();
1060           if (c < 0)
1061             perror_with_name("connect");
1062
1063           printf_monitor("%c", c);
1064           switch (cur_esc)
1065             {
1066             case 0:
1067               if (c == '\r')
1068                 cur_esc = c;
1069               break;
1070             case '\r':
1071               if (c == '~')
1072                 cur_esc = c;
1073               else
1074                 cur_esc = 0;
1075               break;
1076             case '~':
1077               if (c == '.' || c == '\004')
1078                 return;
1079               else
1080                 cur_esc = 0;
1081             }
1082         }
1083
1084       if (FD_ISSET(monitor_desc, &readfds))
1085         {
1086           while (1)
1087             {
1088               c = readchar(0);
1089               if (c < 0)
1090                 break;
1091               putchar(c);
1092             }
1093           fflush(stdout);
1094         }
1095     }
1096 }
1097 #endif
1098
1099 /*
1100  * Define the monitor command strings. Since these are passed directly
1101  * through to a printf style function, we need can include formatting
1102  * strings. We also need a CR or LF on the end.
1103  */
1104 struct monitor_ops rombug_cmds = {
1105   "g \r",                               /* execute or usually GO command */
1106   "g \r",                               /* continue command */
1107   "gs \r",                              /* single step */
1108   "b %x\r",                             /* set a breakpoint */
1109   "k %x\r",                             /* clear a breakpoint */
1110   "c %x\r",                             /* set memory to a value */
1111   "d %x %d\r",                          /* display memory */
1112   "$%08X",                              /* prompt memory commands use */
1113   ".%s %x\r",                           /* set a register */
1114   ":",                                  /* delimiter between registers */
1115   ". \r",                               /* read a register */
1116   "mf \r",                              /* download command */
1117   "RomBug: ",                           /* monitor command prompt */
1118   ": ",                                 /* end-of-command delimitor */
1119   ".\r"                                 /* optional command terminator */
1120 };
1121
1122 struct target_ops rombug_ops = {
1123   "rombug",
1124   "Microware's ROMBUG debug monitor",
1125   "Use a remote computer running the ROMBUG debug monitor.\n\
1126 Specify the serial device it is connected to (e.g. /dev/ttya).",
1127   rombug_open,
1128   rombug_close,
1129   0,
1130   rombug_detach,
1131   rombug_resume,
1132   rombug_wait,
1133   rombug_fetch_register,
1134   rombug_store_register,
1135   rombug_prepare_to_store,
1136   rombug_xfer_inferior_memory,
1137   rombug_files_info,
1138   rombug_insert_breakpoint,
1139   rombug_remove_breakpoint,     /* Breakpoints */
1140   0,
1141   0,
1142   0,
1143   0,
1144   0,                            /* Terminal handling */
1145   rombug_kill,
1146   rombug_load,                  /* load */
1147   rombug_link,                  /* lookup_symbol */
1148   rombug_create_inferior,
1149   rombug_mourn_inferior,
1150   0,                            /* can_run */
1151   0,                            /* notice_signals */
1152   process_stratum,
1153   0,                            /* next */
1154   1,
1155   1,
1156   1,
1157   1,
1158   1,                            /* has execution */
1159   0,
1160   0,                            /* Section pointers */
1161   OPS_MAGIC,                    /* Always the last thing */
1162 };
1163
1164 void
1165 _initialize_remote_os9k ()
1166 {
1167   add_target (&rombug_ops);
1168
1169   add_show_from_set (
1170         add_set_cmd ("hash", no_class, var_boolean, (char *)&hashmark,
1171                 "Set display of activity while downloading a file.\nWhen enabled, a period \'.\' is displayed.",
1172                 &setlist),
1173         &showlist);
1174
1175   add_show_from_set (
1176         add_set_cmd ("timeout", no_class, var_zinteger,
1177                  (char *) &timeout,
1178                  "Set timeout in seconds for remote MIPS serial I/O.",
1179                  &setlist),
1180         &showlist);
1181
1182
1183   add_com ("rombug <command>", class_obscure, rombug_command,
1184            "Send a command to the debug monitor.");
1185 #if 0
1186   add_com ("connect", class_obscure, connect_command,
1187            "Connect the terminal directly up to a serial based command monitor.\nUse <CR>~. or <CR>~^D to break out.");
1188 #endif
1189 }