gdb/remote-mm.c

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