gdb/remote-mm.c

   1 /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
   2    Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   3    Originally written by Daniel Mann at AMD.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 /* This is like remote.c but ecpects MiniMON to be running on the Am29000
  23    target hardware.
  24    - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this
  25    file to gdb 3.95.  I was unable to get this working on sun3os4
  26    with termio, only with sgtty.  Because we are only attempting to
  27    use this module to debug our kernel, which is already loaded when
  28    gdb is started up, I did not code up the file downloading facilities.
  29    As a result this module has only the stubs to download files.
  30    You should get tagged at compile time if you need to make any
  31    changes/additions.  */
  32
  33 #include "defs.h"
  34 #include "inferior.h"
  35 #include "wait.h"
  36 #include "value.h"
  37 #include <ctype.h>
  38 #include <fcntl.h>
  39 #include <signal.h>
  40 #include <errno.h>
  41 #include "gdb_string.h"
  42 #include "terminal.h"
  43 #include "minimon.h"
  44 #include "target.h"
  45
  46 /* Offset of member MEMBER in a struct of type TYPE.  */
  47 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
  48
  49 #define DRAIN_INPUT()   (msg_recv_serial((union msg_t*)0))
  50
  51 extern int stop_soon_quietly;   /* for wait_for_inferior */
  52
  53 static void mm_resume ();
  54 static void mm_fetch_registers ();
  55 static int fetch_register ();
  56 static void mm_store_registers ();
  57 static int store_register ();
  58 static int regnum_to_srnum ();
  59 static void mm_close ();
  60 static char *msg_str ();
  61 static char *error_msg_str ();
  62 static int expect_msg ();
  63 static void init_target_mm ();
  64 static int mm_memory_space ();
  65
  66 #define FREEZE_MODE     (read_register(CPS_REGNUM) && 0x400)
  67 #define USE_SHADOW_PC   ((processor_type == a29k_freeze_mode) && FREEZE_MODE)
  68
  69 /* FIXME: Replace with `set remotedebug'.  */
  70 #define LLOG_FILE "minimon.log"
  71 #if defined (LOG_FILE)
  72 FILE *log_file;
  73 #endif
  74
  75 /*
  76  * Size of message buffers.  I couldn't get memory reads to work when
  77  * the byte_count was larger than 512 (it may be a baud rate problem).
  78  */
  79 #define BUFER_SIZE  512
  80 /*
  81  * Size of data area in message buffer on the TARGET (remote system).
  82  */
  83 #define MAXDATA_T  (target_config.max_msg_size - \
  84                         offsetof(struct write_r_msg_t,data[0]))
  85 /*
  86  * Size of data area in message buffer on the HOST (gdb).
  87  */
  88 #define MAXDATA_H  (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
  89 /*
  90  * Defined as the minimum size of data areas of the two message buffers
  91  */
  92 #define MAXDATA    (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
  93
  94 static char out_buf[BUFER_SIZE];
  95 static char in_buf[BUFER_SIZE];
  96
  97 int msg_recv_serial ();
  98 int msg_send_serial ();
  99
 100 #define MAX_RETRIES 5000
 101 extern struct target_ops mm_ops;        /* Forward declaration */
 102 struct config_msg_t target_config;      /* HIF needs this */
 103 union msg_t *out_msg_buf = (union msg_t *) out_buf;
 104 union msg_t *in_msg_buf = (union msg_t *) in_buf;
 105
 106 static int timeout = 5;
 107
 108 /* Descriptor for I/O to remote machine.  Initialize it to -1 so that
 109    mm_open knows that we don't have a file open when the program
 110    starts.  */
 111 int mm_desc = -1;
 112
 113 /* stream which is fdopen'd from mm_desc.  Only valid when
 114    mm_desc != -1.  */
 115 FILE *mm_stream;
 116
 117 /* Called when SIGALRM signal sent due to alarm() timeout.  */
 118 #ifndef HAVE_TERMIO
 119
 120 #ifndef __STDC__
 121 #ifndef volatile
 122 #define volatile
 123 /**/
 124 # endif
 125 #endif
 126 volatile int n_alarms;
 127
 128 static void
 129 mm_timer ()
 130 {
 131 #if 0
 132   if (kiodebug)
 133     printf ("mm_timer called\n");
 134 #endif
 135   n_alarms++;
 136 }
 137 #endif  /* HAVE_TERMIO */
 138
 139 /* malloc'd name of the program on the remote system.  */
 140 static char *prog_name = NULL;
 141
 142
 143 /* Number of SIGTRAPs we need to simulate.  That is, the next
 144    NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
 145    SIGTRAP without actually waiting for anything.  */
 146
 147 /**************************************************** REMOTE_CREATE_INFERIOR */
 148 /* This is called not only when we first attach, but also when the
 149    user types "run" after having attached.  */
 150 static void
 151 mm_create_inferior (execfile, args, env)
 152      char *execfile;
 153      char *args;
 154      char **env;
 155 {
 156 #define MAX_TOKENS 25
 157 #define BUFFER_SIZE 256
 158   int token_count;
 159   int result;
 160   char *token[MAX_TOKENS];
 161   char cmd_line[BUFFER_SIZE];
 162
 163   if (args && *args)
 164     error ("Can't pass arguments to remote mm process (yet).");
 165
 166   if (execfile == 0 /* || exec_bfd == 0 */ )
 167     error ("No executable file specified");
 168
 169   if (!mm_stream)
 170     {
 171       printf ("Minimon not open yet.\n");
 172       return;
 173     }
 174
 175   /* On ultra3 (NYU) we assume the kernel is already running so there is
 176      no file to download.
 177      FIXME: Fixed required here -> load your program, possibly with mm_load().
 178    */
 179   printf_filtered ("\n\
 180 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
 181
 182   /* We will get a task spawn event immediately.  */
 183   init_wait_for_inferior ();
 184   clear_proceed_status ();
 185   stop_soon_quietly = 1;
 186   proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
 187   normal_stop ();
 188 }
 189 /**************************************************** REMOTE_MOURN_INFERIOR */
 190 static void
 191 mm_mourn ()
 192 {
 193   pop_target ();                /* Pop back to no-child state */
 194   generic_mourn_inferior ();
 195 }
 196
 197 /********************************************************************** damn_b
 198 */
 199 /* Translate baud rates from integers to damn B_codes.  Unix should
 200    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 201
 202 #ifndef B19200
 203 #define B19200 EXTA
 204 #endif
 205 #ifndef B38400
 206 #define B38400 EXTB
 207 #endif
 208
 209 static struct
 210 {
 211   int rate, damn_b;
 212 }
 213 baudtab[] =
 214 {
 215   {
 216     0, B0
 217   }
 218   ,
 219   {
 220     50, B50
 221   }
 222   ,
 223   {
 224     75, B75
 225   }
 226   ,
 227   {
 228     110, B110
 229   }
 230   ,
 231   {
 232     134, B134
 233   }
 234   ,
 235   {
 236     150, B150
 237   }
 238   ,
 239   {
 240     200, B200
 241   }
 242   ,
 243   {
 244     300, B300
 245   }
 246   ,
 247   {
 248     600, B600
 249   }
 250   ,
 251   {
 252     1200, B1200
 253   }
 254   ,
 255   {
 256     1800, B1800
 257   }
 258   ,
 259   {
 260     2400, B2400
 261   }
 262   ,
 263   {
 264     4800, B4800
 265   }
 266   ,
 267   {
 268     9600, B9600
 269   }
 270   ,
 271   {
 272     19200, B19200
 273   }
 274   ,
 275   {
 276     38400, B38400
 277   }
 278   ,
 279   {
 280     -1, -1
 281   }
 282   ,
 283 };
 284
 285 static int
 286 damn_b (rate)
 287      int rate;
 288 {
 289   int i;
 290
 291   for (i = 0; baudtab[i].rate != -1; i++)
 292     if (rate == baudtab[i].rate)
 293       return baudtab[i].damn_b;
 294   return B38400;                /* Random */
 295 }
 296
 297
 298 /***************************************************************** REMOTE_OPEN
 299 ** Open a connection to remote minimon.
 300    NAME is the filename used for communication, then a space,
 301    then the baud rate.
 302    'target adapt /dev/ttya 9600 [prognam]' for example.
 303  */
 304
 305 static char *dev_name;
 306 int baudrate = 9600;
 307 static void
 308 mm_open (name, from_tty)
 309      char *name;
 310      int from_tty;
 311 {
 312   TERMINAL sg;
 313   unsigned int prl;
 314   char *p;
 315
 316   /* Find the first whitespace character, it separates dev_name from
 317      prog_name.  */
 318   for (p = name;
 319        p && *p && !isspace (*p); p++)
 320     ;
 321   if (p == 0 || *p == '\0')
 322   erroid:
 323     error ("Usage : <command> <serial-device> <baud-rate> [progname]");
 324   dev_name = (char *) xmalloc (p - name + 1);
 325   strncpy (dev_name, name, p - name);
 326   dev_name[p - name] = '\0';
 327
 328   /* Skip over the whitespace after dev_name */
 329   for (; isspace (*p); p++)
 330     /*EMPTY */ ;
 331
 332   if (1 != sscanf (p, "%d ", &baudrate))
 333     goto erroid;
 334
 335   /* Skip the number and then the spaces */
 336   for (; isdigit (*p); p++)
 337     /*EMPTY */ ;
 338   for (; isspace (*p); p++)
 339     /*EMPTY */ ;
 340
 341   if (prog_name != NULL)
 342     free (prog_name);
 343   prog_name = savestring (p, strlen (p));
 344
 345
 346   if (mm_desc >= 0)
 347     close (mm_desc);
 348
 349   mm_desc = open (dev_name, O_RDWR);
 350   if (mm_desc < 0)
 351     perror_with_name (dev_name);
 352   ioctl (mm_desc, TIOCGETP, &sg);
 353 #ifdef HAVE_TERMIO
 354   sg.c_cc[VMIN] = 0;            /* read with timeout.  */
 355   sg.c_cc[VTIME] = timeout * 10;
 356   sg.c_lflag &= ~(ICANON | ECHO);
 357   sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
 358 #else
 359   sg.sg_ispeed = damn_b (baudrate);
 360   sg.sg_ospeed = damn_b (baudrate);
 361   sg.sg_flags |= RAW;
 362   sg.sg_flags |= ANYP;
 363   sg.sg_flags &= ~ECHO;
 364 #endif
 365
 366
 367   ioctl (mm_desc, TIOCSETP, &sg);
 368   mm_stream = fdopen (mm_desc, "r+");
 369
 370   push_target (&mm_ops);
 371
 372 #ifndef HAVE_TERMIO
 373 #ifndef NO_SIGINTERRUPT
 374   /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
 375      the read.  */
 376   if (siginterrupt (SIGALRM, 1) != 0)
 377     perror ("mm_open: error in siginterrupt");
 378 #endif
 379
 380   /* Set up read timeout timer.  */
 381   if ((void (*)) signal (SIGALRM, mm_timer) == (void (*)) -1)
 382     perror ("mm_open: error in signal");
 383 #endif
 384
 385 #if defined (LOG_FILE)
 386   log_file = fopen (LOG_FILE, "w");
 387   if (log_file == NULL)
 388     perror_with_name (LOG_FILE);
 389 #endif
 390   /*
 391      ** Initialize target configuration structure (global)
 392    */
 393   DRAIN_INPUT ();
 394   out_msg_buf->config_req_msg.code = CONFIG_REQ;
 395   out_msg_buf->config_req_msg.length = 4 * 0;
 396   msg_send_serial (out_msg_buf);        /* send config request message */
 397
 398   expect_msg (CONFIG, in_msg_buf, 1);
 399
 400   a29k_get_processor_type ();
 401
 402   /* Print out some stuff, letting the user now what's going on */
 403   printf_filtered ("Connected to MiniMon via %s.\n", dev_name);
 404   /* FIXME: can this restriction be removed? */
 405   printf_filtered ("Remote debugging using virtual addresses works only\n");
 406   printf_filtered ("\twhen virtual addresses map 1:1 to physical addresses.\n")
 407     ;
 408   if (processor_type != a29k_freeze_mode)
 409     {
 410       fprintf_filtered (gdb_stderr,
 411                         "Freeze-mode debugging not available, and can only be done on an A29050.\n");
 412     }
 413
 414   target_config.code = CONFIG;
 415   target_config.length = 0;
 416   target_config.processor_id = in_msg_buf->config_msg.processor_id;
 417   target_config.version = in_msg_buf->config_msg.version;
 418   target_config.I_mem_start = in_msg_buf->config_msg.I_mem_start;
 419   target_config.I_mem_size = in_msg_buf->config_msg.I_mem_size;
 420   target_config.D_mem_start = in_msg_buf->config_msg.D_mem_start;
 421   target_config.D_mem_size = in_msg_buf->config_msg.D_mem_size;
 422   target_config.ROM_start = in_msg_buf->config_msg.ROM_start;
 423   target_config.ROM_size = in_msg_buf->config_msg.ROM_size;
 424   target_config.max_msg_size = in_msg_buf->config_msg.max_msg_size;
 425   target_config.max_bkpts = in_msg_buf->config_msg.max_bkpts;
 426   target_config.coprocessor = in_msg_buf->config_msg.coprocessor;
 427   target_config.reserved = in_msg_buf->config_msg.reserved;
 428   if (from_tty)
 429     {
 430       printf ("Connected to MiniMON :\n");
 431       printf ("    Debugcore version            %d.%d\n",
 432               0x0f & (target_config.version >> 4),
 433               0x0f & (target_config.version));
 434       printf ("    Configuration version        %d.%d\n",
 435               0x0f & (target_config.version >> 12),
 436               0x0f & (target_config.version >> 8));
 437       printf ("    Message system version       %d.%d\n",
 438               0x0f & (target_config.version >> 20),
 439               0x0f & (target_config.version >> 16));
 440       printf ("    Communication driver version %d.%d\n",
 441               0x0f & (target_config.version >> 28),
 442               0x0f & (target_config.version >> 24));
 443     }
 444
 445   /* Leave the target running...
 446    * The above message stopped the target in the dbg core (MiniMon),
 447    * so restart the target out of MiniMon,
 448    */
 449   out_msg_buf->go_msg.code = GO;
 450   out_msg_buf->go_msg.length = 0;
 451   msg_send_serial (out_msg_buf);
 452   /* No message to expect after a GO */
 453 }
 454
 455 /**************************************************************** REMOTE_CLOSE
 456 ** Close the open connection to the minimon debugger.
 457    Use this when you want to detach and do something else
 458    with your gdb.  */
 459 static void
 460 mm_close (quitting)             /*FIXME: how is quitting used */
 461      int quitting;
 462 {
 463   if (mm_desc < 0)
 464     error ("Can't close remote connection: not debugging remotely.");
 465
 466   /* We should never get here if there isn't something valid in
 467      mm_desc and mm_stream.
 468
 469      Due to a bug in Unix, fclose closes not only the stdio stream,
 470      but also the file descriptor.  So we don't actually close
 471      mm_desc.  */
 472   DRAIN_INPUT ();
 473   fclose (mm_stream);
 474   /* close (mm_desc); */
 475
 476   /* Do not try to close mm_desc again, later in the program.  */
 477   mm_stream = NULL;
 478   mm_desc = -1;
 479
 480 #if defined (LOG_FILE)
 481   if (ferror (log_file))
 482     printf ("Error writing log file.\n");
 483   if (fclose (log_file) != 0)
 484     printf ("Error closing log file.\n");
 485 #endif
 486
 487   printf ("Ending remote debugging\n");
 488 }
 489
 490 /************************************************************* REMOTE_ATACH */
 491 /* Attach to a program that is already loaded and running
 492  * Upon exiting the process's execution is stopped.
 493  */
 494 static void
 495 mm_attach (args, from_tty)
 496      char *args;
 497      int from_tty;
 498 {
 499
 500   if (!mm_stream)
 501     error ("MiniMon not opened yet, use the 'target minimon' command.\n");
 502
 503   if (from_tty)
 504     printf ("Attaching to remote program %s...\n", prog_name);
 505
 506   /* Make sure the target is currently running, it is supposed to be. */
 507   /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
 508    *  the dbg core.  If so, we don't need to send this GO.
 509    */
 510   out_msg_buf->go_msg.code = GO;
 511   out_msg_buf->go_msg.length = 0;
 512   msg_send_serial (out_msg_buf);
 513   sleep (2);                    /* At the worst it will stop, receive a message, continue */
 514
 515   /* Send the mm a break. */
 516   out_msg_buf->break_msg.code = BREAK;
 517   out_msg_buf->break_msg.length = 0;
 518   msg_send_serial (out_msg_buf);
 519 }
 520 /********************************************************** REMOTE_DETACH */
 521 /* Terminate the open connection to the remote debugger.
 522    Use this when you want to detach and do something else
 523    with your gdb.  Leave remote process running (with no breakpoints set). */
 524 static void
 525 mm_detach (args, from_tty)
 526      char *args;
 527      int from_tty;
 528 {
 529   remove_breakpoints ();        /* Just in case there were any left in */
 530   out_msg_buf->go_msg.code = GO;
 531   out_msg_buf->go_msg.length = 0;
 532   msg_send_serial (out_msg_buf);
 533   pop_target ();                /* calls mm_close to do the real work */
 534 }
 535
 536
 537 /*************************************************************** REMOTE_RESUME
 538 ** Tell the remote machine to resume.  */
 539
 540 static void
 541 mm_resume (pid, step, sig)
 542      int pid, step;
 543      enum target_signal sig;
 544 {
 545   if (sig != TARGET_SIGNAL_0)
 546     warning ("Can't send signals to a remote MiniMon system.");
 547
 548   if (step)
 549     {
 550       out_msg_buf->step_msg.code = STEP;
 551       out_msg_buf->step_msg.length = 1 * 4;
 552       out_msg_buf->step_msg.count = 1;  /* step 1 instruction */
 553       msg_send_serial (out_msg_buf);
 554     }
 555   else
 556     {
 557       out_msg_buf->go_msg.code = GO;
 558       out_msg_buf->go_msg.length = 0;
 559       msg_send_serial (out_msg_buf);
 560     }
 561 }
 562
 563 /***************************************************************** REMOTE_WAIT
 564 ** Wait until the remote machine stops, then return,
 565    storing status in STATUS just as `wait' would.  */
 566
 567 static int
 568 mm_wait (status)
 569      struct target_waitstatus *status;
 570 {
 571   int i, result;
 572   int old_timeout = timeout;
 573   int old_immediate_quit = immediate_quit;
 574
 575   status->kind = TARGET_WAITKIND_EXITED;
 576   status->value.integer = 0;
 577
 578 /* wait for message to arrive. It should be:
 579    - A HIF service request.
 580    - A HIF exit service request.
 581    - A CHANNEL0_ACK.
 582    - A CHANNEL1 request.
 583    - a debugcore HALT message.
 584    HIF services must be responded too, and while-looping continued.
 585    If the target stops executing, mm_wait() should return.
 586  */
 587   timeout = 0;                  /* Wait indefinetly for a message */
 588   immediate_quit = 1;           /* Helps ability to QUIT */
 589   while (1)
 590     {
 591       while (msg_recv_serial (in_msg_buf))
 592         {
 593           QUIT;                 /* Let user quit if they want */
 594         }
 595       switch (in_msg_buf->halt_msg.code)
 596         {
 597         case HIF_CALL:
 598           i = in_msg_buf->hif_call_rtn_msg.service_number;
 599           result = service_HIF (in_msg_buf);
 600           if (i == 1)           /* EXIT */
 601             goto exit;
 602           if (result)
 603             printf ("Warning: failure during HIF service %d\n", i);
 604           break;
 605         case CHANNEL0_ACK:
 606           service_HIF (in_msg_buf);
 607           break;
 608         case CHANNEL1:
 609           i = in_msg_buf->channel1_msg.length;
 610           in_msg_buf->channel1_msg.data[i] = '\0';
 611           printf ("%s", in_msg_buf->channel1_msg.data);
 612           gdb_flush (gdb_stdout);
 613           /* Send CHANNEL1_ACK message */
 614           out_msg_buf->channel1_ack_msg.code = CHANNEL1_ACK;
 615           out_msg_buf->channel1_ack_msg.length = 0;
 616           result = msg_send_serial (out_msg_buf);
 617           break;
 618         case HALT:
 619           goto halted;
 620         default:
 621           goto halted;
 622         }
 623     }
 624 halted:
 625   /* FIXME, these printfs should not be here.  This is a source level
 626      debugger, guys!  */
 627   if (in_msg_buf->halt_msg.trap_number == 0)
 628     {
 629       printf ("Am290*0 received vector number %d (break point)\n",
 630               in_msg_buf->halt_msg.trap_number);
 631       status->kind = TARGET_WAITKIND_STOPPED;
 632       status->value.sig = TARGET_SIGNAL_TRAP;
 633     }
 634   else if (in_msg_buf->halt_msg.trap_number == 1)
 635     {
 636       printf ("Am290*0 received vector number %d\n",
 637               in_msg_buf->halt_msg.trap_number);
 638       status->kind = TARGET_WAITKIND_STOPPED;
 639       status->value.sig = TARGET_SIGNAL_BUS;
 640     }
 641   else if (in_msg_buf->halt_msg.trap_number == 3
 642            || in_msg_buf->halt_msg.trap_number == 4)
 643     {
 644       printf ("Am290*0 received vector number %d\n",
 645               in_msg_buf->halt_msg.trap_number);
 646       status->kind = TARGET_WAITKIND_STOPPED;
 647       status->value.sig = TARGET_SIGNAL_FPE;
 648     }
 649   else if (in_msg_buf->halt_msg.trap_number == 5)
 650     {
 651       printf ("Am290*0 received vector number %d\n",
 652               in_msg_buf->halt_msg.trap_number);
 653       status->kind = TARGET_WAITKIND_STOPPED;
 654       status->value.sig = TARGET_SIGNAL_ILL;
 655     }
 656   else if (in_msg_buf->halt_msg.trap_number >= 6
 657            && in_msg_buf->halt_msg.trap_number <= 11)
 658     {
 659       printf ("Am290*0 received vector number %d\n",
 660               in_msg_buf->halt_msg.trap_number);
 661       status->kind = TARGET_WAITKIND_STOPPED;
 662       status->value.sig = TARGET_SIGNAL_SEGV;
 663     }
 664   else if (in_msg_buf->halt_msg.trap_number == 12
 665            || in_msg_buf->halt_msg.trap_number == 13)
 666     {
 667       printf ("Am290*0 received vector number %d\n",
 668               in_msg_buf->halt_msg.trap_number);
 669       status->kind = TARGET_WAITKIND_STOPPED;
 670       status->value.sig = TARGET_SIGNAL_ILL;
 671     }
 672   else if (in_msg_buf->halt_msg.trap_number == 14)
 673     {
 674       printf ("Am290*0 received vector number %d\n",
 675               in_msg_buf->halt_msg.trap_number);
 676       status->kind = TARGET_WAITKIND_STOPPED;
 677       status->value.sig = TARGET_SIGNAL_ALRM;
 678     }
 679   else if (in_msg_buf->halt_msg.trap_number == 15)
 680     {
 681       status->kind = TARGET_WAITKIND_STOPPED;
 682       status->value.sig = TARGET_SIGNAL_TRAP;
 683     }
 684   else if (in_msg_buf->halt_msg.trap_number >= 16
 685            && in_msg_buf->halt_msg.trap_number <= 21)
 686     {
 687       printf ("Am290*0 received vector number %d\n",
 688               in_msg_buf->halt_msg.trap_number);
 689       status->kind = TARGET_WAITKIND_STOPPED;
 690       status->value.sig = TARGET_SIGNAL_INT;
 691     }
 692   else if (in_msg_buf->halt_msg.trap_number == 22)
 693     {
 694       printf ("Am290*0 received vector number %d\n",
 695               in_msg_buf->halt_msg.trap_number);
 696       status->kind = TARGET_WAITKIND_STOPPED;
 697       status->value.sig = TARGET_SIGNAL_ILL;
 698     }                           /* BREAK message was sent */
 699   else if (in_msg_buf->halt_msg.trap_number == 75)
 700     {
 701       status->kind = TARGET_WAITKIND_STOPPED;
 702       status->value.sig = TARGET_SIGNAL_TRAP;
 703     }
 704   else
 705   exit:
 706     {
 707       status->kind = TARGET_WAITKIND_EXITED;
 708       status->value.integer = 0;
 709     }
 710
 711   timeout = old_timeout;        /* Restore original timeout value */
 712   immediate_quit = old_immediate_quit;
 713   return 0;
 714 }
 715
 716 /******************************************************* REMOTE_FETCH_REGISTERS
 717  * Read a remote register 'regno'.
 718  * If regno==-1 then read all the registers.
 719  */
 720 static void
 721 mm_fetch_registers (regno)
 722      int regno;
 723 {
 724   INT32 *data_p;
 725
 726   if (regno >= 0)
 727     {
 728       fetch_register (regno);
 729       return;
 730     }
 731
 732 /* Gr1/rsp */
 733   out_msg_buf->read_req_msg.byte_count = 4 * 1;
 734   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 735   out_msg_buf->read_req_msg.address = 1;
 736   msg_send_serial (out_msg_buf);
 737   expect_msg (READ_ACK, in_msg_buf, 1);
 738   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 739   supply_register (GR1_REGNUM, data_p);
 740
 741 #if defined(GR64_REGNUM)        /* Read gr64-127 */
 742 /* Global Registers gr64-gr95 */
 743   out_msg_buf->read_req_msg.code = READ_REQ;
 744   out_msg_buf->read_req_msg.length = 4 * 3;
 745   out_msg_buf->read_req_msg.byte_count = 4 * 32;
 746   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 747   out_msg_buf->read_req_msg.address = 64;
 748   msg_send_serial (out_msg_buf);
 749   expect_msg (READ_ACK, in_msg_buf, 1);
 750   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 751
 752   for (regno = GR64_REGNUM; regno < GR64_REGNUM + 32; regno++)
 753     {
 754       supply_register (regno, data_p++);
 755     }
 756 #endif /*  GR64_REGNUM */
 757
 758 /* Global Registers gr96-gr127 */
 759   out_msg_buf->read_req_msg.code = READ_REQ;
 760   out_msg_buf->read_req_msg.length = 4 * 3;
 761   out_msg_buf->read_req_msg.byte_count = 4 * 32;
 762   out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
 763   out_msg_buf->read_req_msg.address = 96;
 764   msg_send_serial (out_msg_buf);
 765   expect_msg (READ_ACK, in_msg_buf, 1);
 766   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 767
 768   for (regno = GR96_REGNUM; regno < GR96_REGNUM + 32; regno++)
 769     {
 770       supply_register (regno, data_p++);
 771     }
 772
 773 /* Local Registers */
 774   out_msg_buf->read_req_msg.byte_count = 4 * (128);
 775   out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
 776   out_msg_buf->read_req_msg.address = 0;
 777   msg_send_serial (out_msg_buf);
 778   expect_msg (READ_ACK, in_msg_buf, 1);
 779   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 780
 781   for (regno = LR0_REGNUM; regno < LR0_REGNUM + 128; regno++)
 782     {
 783       supply_register (regno, data_p++);
 784     }
 785
 786 /* Protected Special Registers */
 787   out_msg_buf->read_req_msg.byte_count = 4 * 15;
 788   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
 789   out_msg_buf->read_req_msg.address = 0;
 790   msg_send_serial (out_msg_buf);
 791   expect_msg (READ_ACK, in_msg_buf, 1);
 792   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 793
 794   for (regno = 0; regno <= 14; regno++)
 795     {
 796       supply_register (SR_REGNUM (regno), data_p++);
 797     }
 798   if (USE_SHADOW_PC)
 799     {                           /* Let regno_to_srnum() handle the register number */
 800       fetch_register (NPC_REGNUM);
 801       fetch_register (PC_REGNUM);
 802       fetch_register (PC2_REGNUM);
 803     }
 804
 805 /* Unprotected Special Registers */
 806   out_msg_buf->read_req_msg.byte_count = 4 * 8;
 807   out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
 808   out_msg_buf->read_req_msg.address = 128;
 809   msg_send_serial (out_msg_buf);
 810   expect_msg (READ_ACK, in_msg_buf, 1);
 811   data_p = &(in_msg_buf->read_r_ack_msg.data[0]);
 812
 813   for (regno = 128; regno <= 135; regno++)
 814     {
 815       supply_register (SR_REGNUM (regno), data_p++);
 816     }
 817
 818   /* There doesn't seem to be any way to get these.  */
 819   {
 820     int val = -1;
 821     supply_register (FPE_REGNUM, &val);
 822     supply_register (INTE_REGNUM, &val);
 823     supply_register (FPS_REGNUM, &val);
 824     supply_register (EXO_REGNUM, &val);
 825   }
 826 }
 827
 828
 829 /****************************************************** REMOTE_STORE_REGISTERS
 830  * Store register regno into the target.
 831  * If regno==-1 then store all the registers.
 832  * Result is 0 for success, -1 for failure.
 833  */
 834
 835 static void
 836 mm_store_registers (regno)
 837      int regno;
 838 {
 839   int result;
 840
 841   if (regno >= 0)
 842     {
 843       store_register (regno);
 844       return;
 845     }
 846
 847   result = 0;
 848
 849   out_msg_buf->write_r_msg.code = WRITE_REQ;
 850
 851 /* Gr1/rsp */
 852   out_msg_buf->write_r_msg.byte_count = 4 * 1;
 853   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 854   out_msg_buf->write_r_msg.memory_space = GLOBAL_REG;
 855   out_msg_buf->write_r_msg.address = 1;
 856   out_msg_buf->write_r_msg.data[0] = read_register (GR1_REGNUM);
 857
 858   msg_send_serial (out_msg_buf);
 859   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 860     {
 861       result = -1;
 862     }
 863
 864 #if defined(GR64_REGNUM)
 865 /* Global registers gr64-gr95 */
 866   out_msg_buf->write_r_msg.byte_count = 4 * (32);
 867   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 868   out_msg_buf->write_r_msg.address = 64;
 869
 870   for (regno = GR64_REGNUM; regno < GR64_REGNUM + 32; regno++)
 871     {
 872       out_msg_buf->write_r_msg.data[regno - GR64_REGNUM] = read_register (regno);
 873     }
 874   msg_send_serial (out_msg_buf);
 875   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 876     {
 877       result = -1;
 878     }
 879 #endif /* GR64_REGNUM */
 880
 881 /* Global registers gr96-gr127 */
 882   out_msg_buf->write_r_msg.byte_count = 4 * (32);
 883   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 884   out_msg_buf->write_r_msg.address = 96;
 885   for (regno = GR96_REGNUM; regno < GR96_REGNUM + 32; regno++)
 886     {
 887       out_msg_buf->write_r_msg.data[regno - GR96_REGNUM] = read_register (regno);
 888     }
 889   msg_send_serial (out_msg_buf);
 890   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 891     {
 892       result = -1;
 893     }
 894
 895 /* Local Registers */
 896   out_msg_buf->write_r_msg.memory_space = LOCAL_REG;
 897   out_msg_buf->write_r_msg.byte_count = 4 * 128;
 898   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 899   out_msg_buf->write_r_msg.address = 0;
 900
 901   for (regno = LR0_REGNUM; regno < LR0_REGNUM + 128; regno++)
 902     {
 903       out_msg_buf->write_r_msg.data[regno - LR0_REGNUM] = read_register (regno);
 904     }
 905   msg_send_serial (out_msg_buf);
 906   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 907     {
 908       result = -1;
 909     }
 910
 911 /* Protected Special Registers */
 912   /* VAB through TMR */
 913   out_msg_buf->write_r_msg.memory_space = SPECIAL_REG;
 914   out_msg_buf->write_r_msg.byte_count = 4 * 10;
 915   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 916   out_msg_buf->write_r_msg.address = 0;
 917   for (regno = 0; regno <= 9; regno++)  /* VAB through TMR */
 918     out_msg_buf->write_r_msg.data[regno] = read_register (SR_REGNUM (regno));
 919   msg_send_serial (out_msg_buf);
 920   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 921     {
 922       result = -1;
 923     }
 924
 925   /* PC0, PC1, PC2 possibly as shadow registers */
 926   out_msg_buf->write_r_msg.byte_count = 4 * 3;
 927   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 928   for (regno = 10; regno <= 12; regno++)        /* LRU and MMU */
 929     out_msg_buf->write_r_msg.data[regno - 10] = read_register (SR_REGNUM (regno));
 930   if (USE_SHADOW_PC)
 931     out_msg_buf->write_r_msg.address = 20;      /* SPC0 */
 932   else
 933     out_msg_buf->write_r_msg.address = 10;      /* PC0 */
 934   msg_send_serial (out_msg_buf);
 935   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 936     {
 937       result = -1;
 938     }
 939
 940   /* LRU and MMU */
 941   out_msg_buf->write_r_msg.byte_count = 4 * 2;
 942   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 943   out_msg_buf->write_r_msg.address = 13;
 944   for (regno = 13; regno <= 14; regno++)        /* LRU and MMU */
 945     out_msg_buf->write_r_msg.data[regno - 13] = read_register (SR_REGNUM (regno));
 946   msg_send_serial (out_msg_buf);
 947   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 948     {
 949       result = -1;
 950     }
 951
 952 /* Unprotected Special Registers */
 953   out_msg_buf->write_r_msg.byte_count = 4 * 8;
 954   out_msg_buf->write_r_msg.length = 3 * 4 + out_msg_buf->write_r_msg.byte_count;
 955   out_msg_buf->write_r_msg.address = 128;
 956   for (regno = 128; regno <= 135; regno++)
 957     out_msg_buf->write_r_msg.data[regno - 128] = read_register (SR_REGNUM (regno));
 958   msg_send_serial (out_msg_buf);
 959   if (!expect_msg (WRITE_ACK, in_msg_buf, 1))
 960     {
 961       result = -1;
 962     }
 963
 964   registers_changed ();
 965 }
 966
 967 /*************************************************** REMOTE_PREPARE_TO_STORE */
 968 /* Get ready to modify the registers array.  On machines which store
 969    individual registers, this doesn't need to do anything.  On machines
 970    which store all the registers in one fell swoop, this makes sure
 971    that registers contains all the registers from the program being
 972    debugged.  */
 973
 974 static void
 975 mm_prepare_to_store ()
 976 {
 977   /* Do nothing, since we can store individual regs */
 978 }
 979
 980 /******************************************************* REMOTE_XFER_MEMORY */
 981 static CORE_ADDR
 982 translate_addr (addr)
 983      CORE_ADDR addr;
 984 {
 985 #if defined(KERNEL_DEBUGGING)
 986   /* Check for a virtual address in the kernel */
 987   /* Assume physical address of ublock is in  paddr_u register */
 988   /* FIXME: doesn't work for user virtual addresses */
 989   if (addr >= UVADDR)
 990     {
 991       /* PADDR_U register holds the physical address of the ublock */
 992       CORE_ADDR i = (CORE_ADDR) read_register (PADDR_U_REGNUM);
 993       return (i + addr - (CORE_ADDR) UVADDR);
 994     }
 995   else
 996     {
 997       return (addr);
 998     }
 999 #else
1000   return (addr);
1001 #endif
1002 }
1003
1004 /******************************************************* REMOTE_FILES_INFO */
1005 static void
1006 mm_files_info ()
1007 {
1008   printf ("\tAttached to %s at %d baud and running program %s.\n",
1009           dev_name, baudrate, prog_name);
1010 }
1011
1012 /************************************************* REMOTE_INSERT_BREAKPOINT */
1013 static int
1014 mm_insert_breakpoint (addr, contents_cache)
1015      CORE_ADDR addr;
1016      char *contents_cache;
1017 {
1018   out_msg_buf->bkpt_set_msg.code = BKPT_SET;
1019   out_msg_buf->bkpt_set_msg.length = 4 * 4;
1020   out_msg_buf->bkpt_set_msg.memory_space = I_MEM;
1021   out_msg_buf->bkpt_set_msg.bkpt_addr = (ADDR32) addr;
1022   out_msg_buf->bkpt_set_msg.pass_count = 1;
1023   out_msg_buf->bkpt_set_msg.bkpt_type = -1;     /* use illop for 29000 */
1024   msg_send_serial (out_msg_buf);
1025   if (expect_msg (BKPT_SET_ACK, in_msg_buf, 1))
1026     {
1027       return 0;                 /* Success */
1028     }
1029   else
1030     {
1031       return 1;                 /* Failure */
1032     }
1033 }
1034
1035 /************************************************* REMOTE_DELETE_BREAKPOINT */
1036 static int
1037 mm_remove_breakpoint (addr, contents_cache)
1038      CORE_ADDR addr;
1039      char *contents_cache;
1040 {
1041   out_msg_buf->bkpt_rm_msg.code = BKPT_RM;
1042   out_msg_buf->bkpt_rm_msg.length = 4 * 3;
1043   out_msg_buf->bkpt_rm_msg.memory_space = I_MEM;
1044   out_msg_buf->bkpt_rm_msg.bkpt_addr = (ADDR32) addr;
1045   msg_send_serial (out_msg_buf);
1046   if (expect_msg (BKPT_RM_ACK, in_msg_buf, 1))
1047     {
1048       return 0;                 /* Success */
1049     }
1050   else
1051     {
1052       return 1;                 /* Failure */
1053     }
1054 }
1055
1056
1057 /******************************************************* REMOTE_KILL */
1058 static void
1059 mm_kill (arg, from_tty)
1060      char *arg;
1061      int from_tty;
1062 {
1063   char buf[4];
1064
1065 #if defined(KERNEL_DEBUGGING)
1066   /* We don't ever kill the kernel */
1067   if (from_tty)
1068     {
1069       printf ("Kernel not killed, but left in current state.\n");
1070       printf ("Use detach to leave kernel running.\n");
1071     }
1072 #else
1073   out_msg_buf->break_msg.code = BREAK;
1074   out_msg_buf->bkpt_set_msg.length = 4 * 0;
1075   expect_msg (HALT, in_msg_buf, from_tty);
1076   if (from_tty)
1077     {
1078       printf ("Target has been stopped.");
1079       printf ("Would you like to do a hardware reset (y/n) [n] ");
1080       fgets (buf, 3, stdin);
1081       if (buf[0] == 'y')
1082         {
1083           out_msg_buf->reset_msg.code = RESET;
1084           out_msg_buf->bkpt_set_msg.length = 4 * 0;
1085           expect_msg (RESET_ACK, in_msg_buf, from_tty);
1086           printf ("Target has been reset.");
1087         }
1088     }
1089   pop_target ();
1090 #endif
1091 }
1092
1093
1094
1095 /***************************************************************************/
1096 /*
1097  * Load a program into the target.
1098  */
1099 static void
1100 mm_load (arg_string, from_tty)
1101      char *arg_string;
1102      int from_tty;
1103 {
1104   dont_repeat ();
1105
1106 #if defined(KERNEL_DEBUGGING)
1107   printf ("The kernel had better be loaded already!  Loading not done.\n");
1108 #else
1109   if (arg_string == 0)
1110     error ("The load command takes a file name");
1111
1112   arg_string = tilde_expand (arg_string);
1113   make_cleanup (free, arg_string);
1114   QUIT;
1115   immediate_quit++;
1116   error ("File loading is not yet supported for MiniMon.");
1117   /* FIXME, code to load your file here... */
1118   /* You may need to do an init_target_mm() */
1119   /* init_target_mm(?,?,?,?,?,?,?,?); */
1120   immediate_quit--;
1121   /* symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
1122 #endif
1123
1124 }
1125
1126 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1127 ** Copy LEN bytes of data from debugger memory at MYADDR
1128    to inferior's memory at MEMADDR.  Returns number of bytes written.  */
1129 static int
1130 mm_write_inferior_memory (memaddr, myaddr, len)
1131      CORE_ADDR memaddr;
1132      char *myaddr;
1133      int len;
1134 {
1135   int i, nwritten;
1136
1137   out_msg_buf->write_req_msg.code = WRITE_REQ;
1138   out_msg_buf->write_req_msg.memory_space = mm_memory_space (memaddr);
1139
1140   nwritten = 0;
1141   while (nwritten < len)
1142     {
1143       int num_to_write = len - nwritten;
1144       if (num_to_write > MAXDATA)
1145         num_to_write = MAXDATA;
1146       for (i = 0; i < num_to_write; i++)
1147         out_msg_buf->write_req_msg.data[i] = myaddr[i + nwritten];
1148       out_msg_buf->write_req_msg.byte_count = num_to_write;
1149       out_msg_buf->write_req_msg.length = 3 * 4 + num_to_write;
1150       out_msg_buf->write_req_msg.address = memaddr + nwritten;
1151       msg_send_serial (out_msg_buf);
1152
1153       if (expect_msg (WRITE_ACK, in_msg_buf, 1))
1154         {
1155           nwritten += in_msg_buf->write_ack_msg.byte_count;
1156         }
1157       else
1158         {
1159           break;
1160         }
1161     }
1162   return (nwritten);
1163 }
1164
1165 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1166 ** Read LEN bytes from inferior memory at MEMADDR.  Put the result
1167    at debugger address MYADDR.  Returns number of bytes read.  */
1168 static int
1169 mm_read_inferior_memory (memaddr, myaddr, len)
1170      CORE_ADDR memaddr;
1171      char *myaddr;
1172      int len;
1173 {
1174   int i, nread;
1175
1176   out_msg_buf->read_req_msg.code = READ_REQ;
1177   out_msg_buf->read_req_msg.memory_space = mm_memory_space (memaddr);
1178
1179   nread = 0;
1180   while (nread < len)
1181     {
1182       int num_to_read = (len - nread);
1183       if (num_to_read > MAXDATA)
1184         num_to_read = MAXDATA;
1185       out_msg_buf->read_req_msg.byte_count = num_to_read;
1186       out_msg_buf->read_req_msg.length = 3 * 4 + num_to_read;
1187       out_msg_buf->read_req_msg.address = memaddr + nread;
1188       msg_send_serial (out_msg_buf);
1189
1190       if (expect_msg (READ_ACK, in_msg_buf, 1))
1191         {
1192           for (i = 0; i < in_msg_buf->read_ack_msg.byte_count; i++)
1193             myaddr[i + nread] = in_msg_buf->read_ack_msg.data[i];
1194           nread += in_msg_buf->read_ack_msg.byte_count;
1195         }
1196       else
1197         {
1198           break;
1199         }
1200     }
1201   return (nread);
1202 }
1203
1204 /* FIXME!  Merge these two.  */
1205 static int
1206 mm_xfer_inferior_memory (memaddr, myaddr, len, write)
1207      CORE_ADDR memaddr;
1208      char *myaddr;
1209      int len;
1210      int write;
1211 {
1212
1213   memaddr = translate_addr (memaddr);
1214
1215   if (write)
1216     return mm_write_inferior_memory (memaddr, myaddr, len);
1217   else
1218     return mm_read_inferior_memory (memaddr, myaddr, len);
1219 }
1220
1221
1222 /********************************************************** MSG_SEND_SERIAL
1223 ** This function is used to send a message over the
1224 ** serial line.
1225 **
1226 ** If the message is successfully sent, a zero is
1227 ** returned.  If the message was not sendable, a -1
1228 ** is returned.  This function blocks.  That is, it
1229 ** does not return until the message is completely
1230 ** sent, or until an error is encountered.
1231 **
1232 */
1233
1234 int
1235 msg_send_serial (msg_ptr)
1236      union msg_t *msg_ptr;
1237 {
1238   INT32 message_size;
1239   int byte_count;
1240   int result;
1241   char c;
1242
1243   /* Send message header */
1244   byte_count = 0;
1245   message_size = msg_ptr->generic_msg.length + (2 * sizeof (INT32));
1246   do
1247     {
1248       c = *((char *) msg_ptr + byte_count);
1249       result = write (mm_desc, &c, 1);
1250       if (result == 1)
1251         {
1252           byte_count = byte_count + 1;
1253         }
1254     }
1255   while ((byte_count < message_size));
1256
1257   return (0);
1258 }                               /* end msg_send_serial() */
1259
1260 /********************************************************** MSG_RECV_SERIAL
1261 ** This function is used to receive a message over a
1262 ** serial line.
1263 **
1264 ** If the message is waiting in the buffer, a zero is
1265 ** returned and the buffer pointed to by msg_ptr is filled
1266 ** in.  If no message was available, a -1 is returned.
1267 ** If timeout==0, wait indefinetly for a character.
1268 **
1269 */
1270
1271 int
1272 msg_recv_serial (msg_ptr)
1273      union msg_t *msg_ptr;
1274 {
1275   static INT32 length = 0;
1276   static INT32 byte_count = 0;
1277   int result;
1278   char c;
1279   if (msg_ptr == 0)             /* re-sync request */
1280     {
1281       length = 0;
1282       byte_count = 0;
1283 #ifdef HAVE_TERMIO
1284       /* The timeout here is the prevailing timeout set with VTIME */
1285       ->"timeout==0 semantics not supported"
1286         read (mm_desc, in_buf, BUFER_SIZE);
1287 #else
1288       alarm (1);
1289       read (mm_desc, in_buf, BUFER_SIZE);
1290       alarm (0);
1291 #endif
1292       return (0);
1293     }
1294   /* Receive message */
1295 #ifdef HAVE_TERMIO
1296 /* Timeout==0, help support the mm_wait() routine */
1297   ->"timeout==0 semantics not supported (and its nice if they are)"
1298     result = read (mm_desc, &c, 1);
1299 #else
1300   alarm (timeout);
1301   result = read (mm_desc, &c, 1);
1302   alarm (0);
1303 #endif
1304   if (result < 0)
1305     {
1306       if (errno == EINTR)
1307         {
1308           error ("Timeout reading from remote system.");
1309         }
1310       else
1311         perror_with_name ("remote");
1312     }
1313   else if (result == 1)
1314     {
1315       *((char *) msg_ptr + byte_count) = c;
1316       byte_count = byte_count + 1;
1317     }
1318
1319   /* Message header received.  Save message length. */
1320   if (byte_count == (2 * sizeof (INT32)))
1321     length = msg_ptr->generic_msg.length;
1322
1323   if (byte_count >= (length + (2 * sizeof (INT32))))
1324     {
1325       /* Message received */
1326       byte_count = 0;
1327       return (0);
1328     }
1329   else
1330     return (-1);
1331
1332 }                               /* end msg_recv_serial() */
1333
1334 /********************************************************************* KBD_RAW
1335 ** This function is used to put the keyboard in "raw"
1336 ** mode for BSD Unix.  The original status is saved
1337 ** so that it may be restored later.
1338 */
1339 TERMINAL kbd_tbuf;
1340
1341 int
1342 kbd_raw ()
1343 {
1344   int result;
1345   TERMINAL tbuf;
1346
1347   /* Get keyboard termio (to save to restore original modes) */
1348 #ifdef HAVE_TERMIO
1349   result = ioctl (0, TCGETA, &kbd_tbuf);
1350 #else
1351   result = ioctl (0, TIOCGETP, &kbd_tbuf);
1352 #endif
1353   if (result == -1)
1354     return (errno);
1355
1356   /* Get keyboard TERMINAL (for modification) */
1357 #ifdef HAVE_TERMIO
1358   result = ioctl (0, TCGETA, &tbuf);
1359 #else
1360   result = ioctl (0, TIOCGETP, &tbuf);
1361 #endif
1362   if (result == -1)
1363     return (errno);
1364
1365   /* Set up new parameters */
1366 #ifdef HAVE_TERMIO
1367   tbuf.c_iflag = tbuf.c_iflag &
1368     ~(INLCR | ICRNL | IUCLC | ISTRIP | IXON | BRKINT);
1369   tbuf.c_lflag = tbuf.c_lflag & ~(ICANON | ISIG | ECHO);
1370   tbuf.c_cc[4] = 0;             /* MIN */
1371   tbuf.c_cc[5] = 0;             /* TIME */
1372 #else
1373   /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1374   tbuf.sg_flags |= RAW;
1375   tbuf.sg_flags |= ANYP;
1376   tbuf.sg_flags &= ~ECHO;
1377 #endif
1378
1379   /* Set keyboard termio to new mode (RAW) */
1380 #ifdef HAVE_TERMIO
1381   result = ioctl (0, TCSETAF, &tbuf);
1382 #else
1383   result = ioctl (0, TIOCSETP, &tbuf);
1384 #endif
1385   if (result == -1)
1386     return (errno);
1387
1388   return (0);
1389 }                               /* end kbd_raw() */
1390
1391
1392
1393 /***************************************************************** KBD_RESTORE
1394 ** This function is used to put the keyboard back in the
1395 ** mode it was in before kbk_raw was called.  Note that
1396 ** kbk_raw() must have been called at least once before
1397 ** kbd_restore() is called.
1398 */
1399
1400 int
1401 kbd_restore ()
1402 {
1403   int result;
1404
1405   /* Set keyboard termio to original mode */
1406 #ifdef HAVE_TERMIO
1407   result = ioctl (0, TCSETAF, &kbd_tbuf);
1408 #else
1409   result = ioctl (0, TIOCGETP, &kbd_tbuf);
1410 #endif
1411
1412   if (result == -1)
1413     return (errno);
1414
1415   return (0);
1416 }                               /* end kbd_cooked() */
1417
1418
1419 /*****************************************************************************/
1420 /* Fetch a single register indicatated by 'regno'.
1421  * Returns 0/-1 on success/failure.
1422  */
1423 static int
1424 fetch_register (regno)
1425      int regno;
1426 {
1427   int result;
1428   out_msg_buf->read_req_msg.code = READ_REQ;
1429   out_msg_buf->read_req_msg.length = 4 * 3;
1430   out_msg_buf->read_req_msg.byte_count = 4;
1431
1432   if (regno == GR1_REGNUM)
1433     {
1434       out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1435       out_msg_buf->read_req_msg.address = 1;
1436     }
1437   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
1438     {
1439       out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1440       out_msg_buf->read_req_msg.address = (regno - GR96_REGNUM) + 96;
1441     }
1442 #if defined(GR64_REGNUM)
1443   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32)
1444     {
1445       out_msg_buf->read_req_msg.memory_space = GLOBAL_REG;
1446       out_msg_buf->read_req_msg.address = (regno - GR64_REGNUM) + 64;
1447     }
1448 #endif /* GR64_REGNUM */
1449   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
1450     {
1451       out_msg_buf->read_req_msg.memory_space = LOCAL_REG;
1452       out_msg_buf->read_req_msg.address = (regno - LR0_REGNUM);
1453     }
1454   else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM)
1455     {
1456       int val = -1;
1457       supply_register (160 + (regno - FPE_REGNUM), &val);
1458       return 0;                 /* Pretend Success */
1459     }
1460   else
1461     {
1462       out_msg_buf->read_req_msg.memory_space = SPECIAL_REG;
1463       out_msg_buf->read_req_msg.address = regnum_to_srnum (regno);
1464     }
1465
1466   msg_send_serial (out_msg_buf);
1467
1468   if (expect_msg (READ_ACK, in_msg_buf, 1))
1469     {
1470       supply_register (regno, &(in_msg_buf->read_r_ack_msg.data[0]));
1471       result = 0;
1472     }
1473   else
1474     {
1475       result = -1;
1476     }
1477   return result;
1478 }
1479 /*****************************************************************************/
1480 /* Store a single register indicated by 'regno'.
1481  * Returns 0/-1 on success/failure.
1482  */
1483 static int
1484 store_register (regno)
1485      int regno;
1486 {
1487   int result;
1488
1489   out_msg_buf->write_req_msg.code = WRITE_REQ;
1490   out_msg_buf->write_req_msg.length = 4 * 4;
1491   out_msg_buf->write_req_msg.byte_count = 4;
1492   out_msg_buf->write_r_msg.data[0] = read_register (regno);
1493
1494   if (regno == GR1_REGNUM)
1495     {
1496       out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1497       out_msg_buf->write_req_msg.address = 1;
1498       /* Setting GR1 changes the numbers of all the locals, so invalidate the
1499        * register cache.  Do this *after* calling read_register, because we want
1500        * read_register to return the value that write_register has just stuffed
1501        * into the registers array, not the value of the register fetched from
1502        * the inferior.
1503        */
1504       registers_changed ();
1505     }
1506 #if defined(GR64_REGNUM)
1507   else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32)
1508     {
1509       out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1510       out_msg_buf->write_req_msg.address = (regno - GR64_REGNUM) + 64;
1511     }
1512 #endif /* GR64_REGNUM */
1513   else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
1514     {
1515       out_msg_buf->write_req_msg.memory_space = GLOBAL_REG;
1516       out_msg_buf->write_req_msg.address = (regno - GR96_REGNUM) + 96;
1517     }
1518   else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
1519     {
1520       out_msg_buf->write_req_msg.memory_space = LOCAL_REG;
1521       out_msg_buf->write_req_msg.address = (regno - LR0_REGNUM);
1522     }
1523   else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM)
1524     {
1525       return 0;                 /* Pretend Success */
1526     }
1527   else
1528     /* An unprotected or protected special register */
1529     {
1530       out_msg_buf->write_req_msg.memory_space = SPECIAL_REG;
1531       out_msg_buf->write_req_msg.address = regnum_to_srnum (regno);
1532     }
1533
1534   msg_send_serial (out_msg_buf);
1535
1536   if (expect_msg (WRITE_ACK, in_msg_buf, 1))
1537     {
1538       result = 0;
1539     }
1540   else
1541     {
1542       result = -1;
1543     }
1544   return result;
1545 }
1546 /****************************************************************************/
1547 /*
1548  * Convert a gdb special register number to a 29000 special register number.
1549  */
1550 static int
1551 regnum_to_srnum (regno)
1552      int regno;
1553 {
1554   switch (regno)
1555     {
1556     case VAB_REGNUM:
1557       return (0);
1558     case OPS_REGNUM:
1559       return (1);
1560     case CPS_REGNUM:
1561       return (2);
1562     case CFG_REGNUM:
1563       return (3);
1564     case CHA_REGNUM:
1565       return (4);
1566     case CHD_REGNUM:
1567       return (5);
1568     case CHC_REGNUM:
1569       return (6);
1570     case RBP_REGNUM:
1571       return (7);
1572     case TMC_REGNUM:
1573       return (8);
1574     case TMR_REGNUM:
1575       return (9);
1576     case NPC_REGNUM:
1577       return (USE_SHADOW_PC ? (20) : (10));
1578     case PC_REGNUM:
1579       return (USE_SHADOW_PC ? (21) : (11));
1580     case PC2_REGNUM:
1581       return (USE_SHADOW_PC ? (22) : (12));
1582     case MMU_REGNUM:
1583       return (13);
1584     case LRU_REGNUM:
1585       return (14);
1586     case IPC_REGNUM:
1587       return (128);
1588     case IPA_REGNUM:
1589       return (129);
1590     case IPB_REGNUM:
1591       return (130);
1592     case Q_REGNUM:
1593       return (131);
1594     case ALU_REGNUM:
1595       return (132);
1596     case BP_REGNUM:
1597       return (133);
1598     case FC_REGNUM:
1599       return (134);
1600     case CR_REGNUM:
1601       return (135);
1602     case FPE_REGNUM:
1603       return (160);
1604     case INTE_REGNUM:
1605       return (161);
1606     case FPS_REGNUM:
1607       return (162);
1608     case EXO_REGNUM:
1609       return (164);
1610     default:
1611       return (255);             /* Failure ? */
1612     }
1613 }
1614 /****************************************************************************/
1615 /*
1616  * Initialize the target debugger (minimon only).
1617  */
1618 static void
1619 init_target_mm (tstart, tend, dstart, dend, entry, ms_size, rs_size, arg_start)
1620      ADDR32 tstart, tend, dstart, dend, entry;
1621      INT32 ms_size, rs_size;
1622      ADDR32 arg_start;
1623 {
1624   out_msg_buf->init_msg.code = INIT;
1625   out_msg_buf->init_msg.length = sizeof (struct init_msg_t) - 2 * sizeof (INT32);
1626   out_msg_buf->init_msg.text_start = tstart;
1627   out_msg_buf->init_msg.text_end = tend;
1628   out_msg_buf->init_msg.data_start = dstart;
1629   out_msg_buf->init_msg.data_end = dend;
1630   out_msg_buf->init_msg.entry_point = entry;
1631   out_msg_buf->init_msg.mem_stack_size = ms_size;
1632   out_msg_buf->init_msg.reg_stack_size = rs_size;
1633   out_msg_buf->init_msg.arg_start = arg_start;
1634   msg_send_serial (out_msg_buf);
1635   expect_msg (INIT_ACK, in_msg_buf, 1);
1636 }
1637 /****************************************************************************/
1638 /*
1639  * Return a pointer to a string representing the given message code.
1640  * Not all messages are represented here, only the ones that we expect
1641  * to be called with.
1642  */
1643 static char *
1644 msg_str (code)
1645      INT32 code;
1646 {
1647   static char cbuf[32];
1648
1649   switch (code)
1650     {
1651     case BKPT_SET_ACK:
1652       sprintf (cbuf, "%s (%d)", "BKPT_SET_ACK", code);
1653       break;
1654     case BKPT_RM_ACK:
1655       sprintf (cbuf, "%s (%d)", "BKPT_RM_ACK", code);
1656       break;
1657     case INIT_ACK:
1658       sprintf (cbuf, "%s (%d)", "INIT_ACK", code);
1659       break;
1660     case READ_ACK:
1661       sprintf (cbuf, "%s (%d)", "READ_ACK", code);
1662       break;
1663     case WRITE_ACK:
1664       sprintf (cbuf, "%s (%d)", "WRITE_ACK", code);
1665       break;
1666     case ERROR:
1667       sprintf (cbuf, "%s (%d)", "ERROR", code);
1668       break;
1669     case HALT:
1670       sprintf (cbuf, "%s (%d)", "HALT", code);
1671       break;
1672     default:
1673       sprintf (cbuf, "UNKNOWN (%d)", code);
1674       break;
1675     }
1676   return (cbuf);
1677 }
1678 /****************************************************************************/
1679 /*
1680  * Selected (not all of them) error codes that we might get.
1681  */
1682 static char *
1683 error_msg_str (code)
1684      INT32 code;
1685 {
1686   static char cbuf[50];
1687
1688   switch (code)
1689     {
1690     case EMFAIL:
1691       return ("EMFAIL: unrecoverable error");
1692     case EMBADADDR:
1693       return ("EMBADADDR: Illegal address");
1694     case EMBADREG:
1695       return ("EMBADREG: Illegal register ");
1696     case EMACCESS:
1697       return ("EMACCESS: Could not access memory");
1698     case EMBADMSG:
1699       return ("EMBADMSG: Unknown message type");
1700     case EMMSG2BIG:
1701       return ("EMMSG2BIG: Message to large");
1702     case EMNOSEND:
1703       return ("EMNOSEND: Could not send message");
1704     case EMNORECV:
1705       return ("EMNORECV: Could not recv message");
1706     case EMRESET:
1707       return ("EMRESET: Could not RESET target");
1708     case EMCONFIG:
1709       return ("EMCONFIG: Could not get target CONFIG");
1710     case EMSTATUS:
1711       return ("EMSTATUS: Could not get target STATUS");
1712     case EMREAD:
1713       return ("EMREAD: Could not READ target memory");
1714     case EMWRITE:
1715       return ("EMWRITE: Could not WRITE target memory");
1716     case EMBKPTSET:
1717       return ("EMBKPTSET: Could not set breakpoint");
1718     case EMBKPTRM:
1719       return ("EMBKPTRM: Could not remove breakpoint");
1720     case EMBKPTSTAT:
1721       return ("EMBKPTSTAT: Could not get breakpoint status");
1722     case EMBKPTNONE:
1723       return ("EMBKPTNONE: All breakpoints in use");
1724     case EMBKPTUSED:
1725       return ("EMBKPTUSED: Breakpoints already in use");
1726     case EMINIT:
1727       return ("EMINIT: Could not init target memory");
1728     case EMGO:
1729       return ("EMGO: Could not start execution");
1730     case EMSTEP:
1731       return ("EMSTEP: Could not single step");
1732     case EMBREAK:
1733       return ("EMBREAK: Could not BREAK");
1734     case EMCOMMERR:
1735       return ("EMCOMMERR: Communication error");
1736     default:
1737       sprintf (cbuf, "error number %d", code);
1738       break;
1739     }                           /* end switch */
1740
1741   return (cbuf);
1742 }
1743 /****************************************************************************/
1744 /*
1745  *  Receive a message and expect it to be of type msgcode.
1746  *  Returns 0/1 on failure/success.
1747  */
1748 static int
1749 expect_msg (msgcode, msg_buf, from_tty)
1750      INT32 msgcode;             /* Msg code we expect */
1751      union msg_t *msg_buf;      /* Where to put  the message received */
1752      int from_tty;              /* Print message on error if non-zero */
1753 {
1754   int retries = 0;
1755   while (msg_recv_serial (msg_buf) && (retries++ < MAX_RETRIES));
1756   if (retries >= MAX_RETRIES)
1757     {
1758       printf ("Expected msg %s, ", msg_str (msgcode));
1759       printf ("no message received!\n");
1760       return (0);               /* Failure */
1761     }
1762
1763   if (msg_buf->generic_msg.code != msgcode)
1764     {
1765       if (from_tty)
1766         {
1767           printf ("Expected msg %s, ", msg_str (msgcode));
1768           printf ("got msg %s\n", msg_str (msg_buf->generic_msg.code));
1769           if (msg_buf->generic_msg.code == ERROR)
1770             printf ("%s\n", error_msg_str (msg_buf->error_msg.error_code));
1771         }
1772       return (0);               /* Failure */
1773     }
1774   return (1);                   /* Success */
1775 }
1776 /****************************************************************************/
1777 /*
1778  * Determine the MiniMon memory space qualifier based on the addr.
1779  * FIXME: Can't distinguis I_ROM/D_ROM.
1780  * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1781  */
1782 static int
1783 mm_memory_space (addr)
1784      CORE_ADDR *addr;
1785 {
1786   ADDR32 tstart = target_config.I_mem_start;
1787   ADDR32 tend = tstart + target_config.I_mem_size;
1788   ADDR32 dstart = target_config.D_mem_start;
1789   ADDR32 dend = tstart + target_config.D_mem_size;
1790   ADDR32 rstart = target_config.ROM_start;
1791   ADDR32 rend = tstart + target_config.ROM_size;
1792
1793   if (((ADDR32) addr >= tstart) && ((ADDR32) addr < tend))
1794     {
1795       return I_MEM;
1796     }
1797   else if (((ADDR32) addr >= dstart) && ((ADDR32) addr < dend))
1798     {
1799       return D_MEM;
1800     }
1801   else if (((ADDR32) addr >= rstart) && ((ADDR32) addr < rend))
1802     {
1803       /* FIXME: how do we determine between D_ROM and I_ROM */
1804       return D_ROM;
1805     }
1806   else                          /* FIXME: what do me do now? */
1807     return D_MEM;               /* Hmmm! */
1808 }
1809
1810 /****************************************************************************/
1811 /*
1812  *  Define the target subroutine names
1813  */
1814 struct target_ops mm_ops;
1815
1816 static void
1817 init_mm_ops (void)
1818 {
1819   mm_ops.to_shortname = "minimon";
1820   mm_ops.to_longname = "Remote AMD/Minimon target";
1821   mm_ops.to_doc = "Remote debug an AMD 290*0 using the MiniMon dbg core on the target";
1822   mm_ops.to_open = mm_open;
1823   mm_ops.to_close = mm_close;
1824   mm_ops.to_attach = mm_attach;
1825   mm_ops.to_post_attach = NULL;
1826   mm_ops.to_require_attach = NULL;
1827   mm_ops.to_detach = mm_detach;
1828   mm_ops.to_require_detach = NULL;
1829   mm_ops.to_resume = mm_resume;
1830   mm_ops.to_wait = mm_wait;
1831   mm_ops.to_post_wait = NULL;
1832   mm_ops.to_fetch_registers = mm_fetch_registers;
1833   mm_ops.to_store_registers = mm_store_registers;
1834   mm_ops.to_prepare_to_store = mm_prepare_to_store;
1835   mm_ops.to_xfer_memory = mm_xfer_inferior_memory;
1836   mm_ops.to_files_info = mm_files_info;
1837   mm_ops.to_insert_breakpoint = mm_insert_breakpoint;
1838   mm_ops.to_remove_breakpoint = mm_remove_breakpoint;
1839   mm_ops.to_terminal_init = 0;
1840   mm_ops.to_terminal_inferior = 0;
1841   mm_ops.to_terminal_ours_for_output = 0;
1842   mm_ops.to_terminal_ours = 0;
1843   mm_ops.to_terminal_info = 0;
1844   mm_ops.to_kill = mm_kill;
1845   mm_ops.to_load = mm_load;
1846   mm_ops.to_lookup_symbol = 0;
1847   mm_ops.to_create_inferior = mm_create_inferior;
1848   mm_ops.to_post_startup_inferior = NULL;
1849   mm_ops.to_acknowledge_created_inferior = NULL;
1850   mm_ops.to_clone_and_follow_inferior = NULL;
1851   mm_ops.to_post_follow_inferior_by_clone = NULL;
1852   mm_ops.to_insert_fork_catchpoint = NULL;
1853   mm_ops.to_remove_fork_catchpoint = NULL;
1854   mm_ops.to_insert_vfork_catchpoint = NULL;
1855   mm_ops.to_remove_vfork_catchpoint = NULL;
1856   mm_ops.to_has_forked = NULL;
1857   mm_ops.to_has_vforked = NULL;
1858   mm_ops.to_can_follow_vfork_prior_to_exec = NULL;
1859   mm_ops.to_post_follow_vfork = NULL;
1860   mm_ops.to_insert_exec_catchpoint = NULL;
1861   mm_ops.to_remove_exec_catchpoint = NULL;
1862   mm_ops.to_has_execd = NULL;
1863   mm_ops.to_reported_exec_events_per_exec_call = NULL;
1864   mm_ops.to_has_exited = NULL;
1865   mm_ops.to_mourn_inferior = mm_mourn;
1866   mm_ops.to_can_run = 0;
1867   mm_ops.to_notice_signals = 0;
1868   mm_ops.to_thread_alive = 0;
1869   mm_ops.to_stop = 0;
1870   mm_ops.to_pid_to_exec_file = NULL;
1871   mm_ops.to_core_file_to_sym_file = NULL;
1872   mm_ops.to_stratum = process_stratum;
1873   mm_ops.DONT_USE = 0;
1874   mm_ops.to_has_all_memory = 1;
1875   mm_ops.to_has_memory = 1;
1876   mm_ops.to_has_stack = 1;
1877   mm_ops.to_has_registers = 1;
1878   mm_ops.to_has_execution = 1;
1879   mm_ops.to_sections = 0;
1880   mm_ops.to_sections_end = 0;
1881   mm_ops.to_magic = OPS_MAGIC;
1882 };
1883
1884 void
1885 _initialize_remote_mm ()
1886 {
1887   init_mm_ops ();
1888   add_target (&mm_ops);
1889 }
1890
1891 #ifdef NO_HIF_SUPPORT
1892 service_HIF (msg)
1893      union msg_t *msg;
1894 {
1895   return (0);                   /* Emulate a failure */
1896 }
1897 #endif