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