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