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.
5 This file is part of GDB.
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.
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.
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. */
21 /* This is like remote.c but ecpects MiniMON to be running on the Am29000
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
45 /* Offset of member MEMBER in a struct of type TYPE. */
46 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
48 /* #define DEBUG 1 /* */
50 # define DENTER(NAME) (printf("Entering %s\n",NAME), fflush(stdout))
51 # define DEXIT(NAME) (printf("Exiting %s\n",NAME), fflush(stdout))
57 #define DRAIN_INPUT() (msg_recv_serial((union msg_t*)0))
59 extern int stop_soon_quietly
; /* for wait_for_inferior */
61 static void mm_resume();
62 static void mm_fetch_registers ();
63 static int fetch_register ();
64 static int mm_store_registers ();
65 static int store_register ();
66 static int regnum_to_srnum();
67 static void mm_close ();
68 static char* msg_str();
69 static char* error_msg_str();
70 static int expect_msg();
71 static void init_target_mm();
72 static int mm_memory_space();
77 #define TYPE_UNKNOWN 0
81 static char *processor_name
[] = { "Unknown", "A29000", "A29030", "A29050" };
82 static int processor_type
=TYPE_UNKNOWN
;
83 #define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
84 #define USE_SHADOW_PC ((processor_type == TYPE_A29050) && FREEZE_MODE)
86 #define LLOG_FILE "minimon.log"
87 #if defined (LOG_FILE)
92 * Size of message buffers. I couldn't get memory reads to work when
93 * the byte_count was larger than 512 (it may be a baud rate problem).
95 #define BUFER_SIZE 512
97 * Size of data area in message buffer on the TARGET (remote system).
99 #define MAXDATA_T (target_config.max_msg_size - \
100 offsetof(struct write_r_msg_t,data[0]))
102 * Size of data area in message buffer on the HOST (gdb).
104 #define MAXDATA_H (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
106 * Defined as the minimum size of data areas of the two message buffers
108 #define MAXDATA (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
110 static char out_buf
[BUFER_SIZE
];
111 static char in_buf
[BUFER_SIZE
];
113 int msg_recv_serial();
114 int msg_send_serial();
116 #define MAX_RETRIES 5000
117 extern struct target_ops mm_ops
; /* Forward declaration */
118 struct config_msg_t target_config
; /* HIF needs this */
119 union msg_t
*out_msg_buf
= (union msg_t
*)out_buf
;
120 union msg_t
*in_msg_buf
= (union msg_t
*)in_buf
;
122 static int timeout
= 5;
124 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
125 mm_open knows that we don't have a file open when the program
129 /* stream which is fdopen'd from mm_desc. Only valid when
133 /* Called when SIGALRM signal sent due to alarm() timeout. */
138 # define volatile /**/
141 volatile int n_alarms
;
148 printf ("mm_timer called\n");
152 #endif /* HAVE_TERMIO */
154 /* malloc'd name of the program on the remote system. */
155 static char *prog_name
= NULL
;
158 /* Number of SIGTRAPs we need to simulate. That is, the next
159 NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
160 SIGTRAP without actually waiting for anything. */
162 /**************************************************** REMOTE_CREATE_INFERIOR */
163 /* This is called not only when we first attach, but also when the
164 user types "run" after having attached. */
166 mm_create_inferior (execfile
, args
, env
)
171 #define MAX_TOKENS 25
172 #define BUFFER_SIZE 256
175 char *token
[MAX_TOKENS
];
176 char cmd_line
[BUFFER_SIZE
];
178 DENTER("mm_create_inferior()");
181 error ("Can't pass arguments to remote mm process (yet).");
183 if (execfile
== 0 /* || exec_bfd == 0 */ )
184 error ("No exec file specified");
187 printf("Minimon not open yet.\n");
191 /* On ultra3 (NYU) we assume the kernel is already running so there is
193 FIXME: Fixed required here -> load your program, possibly with mm_load().
195 printf_filtered ("\n\
196 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
198 /* We will get a task spawn event immediately. */
199 #ifdef NOTDEF /* start_remote() now does a wait without a resume
203 init_wait_for_inferior ();
204 clear_proceed_status ();
205 stop_soon_quietly
= 1;
209 DEXIT("mm_create_inferior()");
211 /**************************************************** REMOTE_MOURN_INFERIOR */
215 DENTER("mm_mourn()");
216 pop_target (); /* Pop back to no-child state */
217 generic_mourn_inferior ();
221 /********************************************************************** damn_b
223 /* Translate baud rates from integers to damn B_codes. Unix should
224 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
233 static struct {int rate
, damn_b
;} baudtab
[] = {
253 static int damn_b (rate
)
258 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
259 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
260 return B38400
; /* Random */
264 /***************************************************************** REMOTE_OPEN
265 ** Open a connection to remote minimon.
266 NAME is the filename used for communication, then a space,
268 'target adapt /dev/ttya 9600 [prognam]' for example.
271 static char *dev_name
;
274 mm_open (name
, from_tty
)
284 /* Find the first whitespace character, it separates dev_name from
287 p
&& *p
&& !isspace (*p
); p
++)
289 if (p
== 0 || *p
== '\0')
291 error ("Usage : <command> <serial-device> <baud-rate> [progname]");
292 dev_name
= (char*)malloc (p
- name
+ 1);
293 strncpy (dev_name
, name
, p
- name
);
294 dev_name
[p
- name
] = '\0';
296 /* Skip over the whitespace after dev_name */
297 for (; isspace (*p
); p
++)
300 if (1 != sscanf (p
, "%d ", &baudrate
))
303 /* Skip the number and then the spaces */
304 for (; isdigit (*p
); p
++)
306 for (; isspace (*p
); p
++)
309 if (prog_name
!= NULL
)
311 prog_name
= savestring (p
, strlen (p
));
317 mm_desc
= open (dev_name
, O_RDWR
);
319 perror_with_name (dev_name
);
320 ioctl (mm_desc
, TIOCGETP
, &sg
);
322 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
323 sg
.c_cc
[VTIME
] = timeout
* 10;
324 sg
.c_lflag
&= ~(ICANON
| ECHO
);
325 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
327 sg
.sg_ispeed
= damn_b (baudrate
);
328 sg
.sg_ospeed
= damn_b (baudrate
);
331 sg
.sg_flags
&= ~ECHO
;
335 ioctl (mm_desc
, TIOCSETP
, &sg
);
336 mm_stream
= fdopen (mm_desc
, "r+");
338 push_target (&mm_ops
);
341 #ifndef NO_SIGINTERRUPT
342 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
344 if (siginterrupt (SIGALRM
, 1) != 0)
345 perror ("mm_open: error in siginterrupt");
348 /* Set up read timeout timer. */
349 if ((void (*)) signal (SIGALRM
, mm_timer
) == (void (*)) -1)
350 perror ("mm_open: error in signal");
353 #if defined (LOG_FILE)
354 log_file
= fopen (LOG_FILE
, "w");
355 if (log_file
== NULL
)
356 perror_with_name (LOG_FILE
);
359 ** Initialize target configuration structure (global)
362 out_msg_buf
->config_req_msg
.code
= CONFIG_REQ
;
363 out_msg_buf
->config_req_msg
.length
= 4*0;
364 msg_send_serial(out_msg_buf
); /* send config request message */
366 expect_msg(CONFIG
,in_msg_buf
,1);
368 /* Determine the processor revision level */
369 /* FIXME: this code is the same as in remote-adapt.c */
370 prl
= (unsigned int)read_register(CFG_REGNUM
) >> 24;
372 processor_type
= TYPE_A29000
;
373 } else if ((prl
&0xf0) == 0x40) { /* 29030 = 0x4* */
374 processor_type
= TYPE_A29030
;
375 fprintf_filtered(stderr
,"WARNING: debugging of A29030 not tested.\n");
376 } else if ((prl
&0xf0) == 0x20) { /* 29050 = 0x2* */
377 processor_type
= TYPE_A29050
;
378 fprintf_filtered(stderr
,"WARNING: debugging of A29050 not tested.\n");
380 processor_type
= TYPE_UNKNOWN
;
381 fprintf_filtered(stderr
,"WARNING: processor type unknown.\n");
384 /* Print out some stuff, letting the user now what's going on */
385 printf_filtered("Remote debugging on an %s connect to MiniMon via %s.\n",
386 processor_name
[processor_type
],dev_name
);
387 /* FIXME: can this restriction be removed? */
388 printf_filtered("Remote debugging using virtual addresses works only\n");
389 printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n")
391 if (processor_type
!= TYPE_A29050
) {
392 fprintf_filtered(stderr
,
393 "Freeze-mode debugging not available, and can only be done on an A29050.\n");
396 target_config
.code
= CONFIG
;
397 target_config
.length
= 0;
398 target_config
.processor_id
= in_msg_buf
->config_msg
.processor_id
;
399 target_config
.version
= in_msg_buf
->config_msg
.version
;
400 target_config
.I_mem_start
= in_msg_buf
->config_msg
.I_mem_start
;
401 target_config
.I_mem_size
= in_msg_buf
->config_msg
.I_mem_size
;
402 target_config
.D_mem_start
= in_msg_buf
->config_msg
.D_mem_start
;
403 target_config
.D_mem_size
= in_msg_buf
->config_msg
.D_mem_size
;
404 target_config
.ROM_start
= in_msg_buf
->config_msg
.ROM_start
;
405 target_config
.ROM_size
= in_msg_buf
->config_msg
.ROM_size
;
406 target_config
.max_msg_size
= in_msg_buf
->config_msg
.max_msg_size
;
407 target_config
.max_bkpts
= in_msg_buf
->config_msg
.max_bkpts
;
408 target_config
.coprocessor
= in_msg_buf
->config_msg
.coprocessor
;
409 target_config
.reserved
= in_msg_buf
->config_msg
.reserved
;
411 printf("Connected to MiniMON :\n");
412 printf(" Debugcore version %d.%d\n",
413 0x0f & (target_config
.version
>> 4),
414 0x0f & (target_config
.version
) );
415 printf(" Configuration version %d.%d\n",
416 0x0f & (target_config
.version
>> 12),
417 0x0f & (target_config
.version
>> 8) );
418 printf(" Message system version %d.%d\n",
419 0x0f & (target_config
.version
>> 20),
420 0x0f & (target_config
.version
>> 16) );
421 printf(" Communication driver version %d.%d\n",
422 0x0f & (target_config
.version
>> 28),
423 0x0f & (target_config
.version
>> 24) );
426 /* Leave the target running...
427 * The above message stopped the target in the dbg core (MiniMon),
428 * so restart the target out of MiniMon,
430 out_msg_buf
->go_msg
.code
= GO
;
431 out_msg_buf
->go_msg
.length
= 0;
432 msg_send_serial(out_msg_buf
);
433 /* No message to expect after a GO */
438 /**************************************************************** REMOTE_CLOSE
439 ** Close the open connection to the minimon debugger.
440 Use this when you want to detach and do something else
443 mm_close (quitting
) /*FIXME: how is quitting used */
446 DENTER("mm_close()");
449 error ("Can't close remote connection: not debugging remotely.");
451 /* We should never get here if there isn't something valid in
452 mm_desc and mm_stream.
454 Due to a bug in Unix, fclose closes not only the stdio stream,
455 but also the file descriptor. So we don't actually close
459 /* close (mm_desc); */
461 /* Do not try to close mm_desc again, later in the program. */
465 #if defined (LOG_FILE)
466 if (ferror (log_file
))
467 printf ("Error writing log file.\n");
468 if (fclose (log_file
) != 0)
469 printf ("Error closing log file.\n");
472 printf ("Ending remote debugging\n");
478 /************************************************************* REMOTE_ATACH */
479 /* Attach to a program that is already loaded and running
480 * Upon exiting the process's execution is stopped.
483 mm_attach (args
, from_tty
)
488 DENTER("mm_attach()");
491 printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
496 printf ("Attaching to remote program %s...\n", prog_name
);
499 /* Make sure the target is currently running, it is supposed to be. */
500 /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
501 * the dbg core. If so, we don't need to send this GO.
503 out_msg_buf
->go_msg
.code
= GO
;
504 out_msg_buf
->go_msg
.length
= 0;
505 msg_send_serial(out_msg_buf
);
506 sleep(2); /* At the worst it will stop, receive a message, continue */
508 /* Send the mm a break. */
509 out_msg_buf
->break_msg
.code
= BREAK
;
510 out_msg_buf
->break_msg
.length
= 0;
511 msg_send_serial(out_msg_buf
);
513 mark_breakpoints_out ();
514 init_wait_for_inferior ();
515 clear_proceed_status ();
516 stop_soon_quietly
= 1;
517 wait_for_inferior ();
518 stop_soon_quietly
= 0;
521 DEXIT("mm_attach()");
523 /********************************************************** REMOTE_DETACH */
524 /* Terminate the open connection to the remote debugger.
525 Use this when you want to detach and do something else
526 with your gdb. Leave remote process running (with no breakpoints set). */
528 mm_detach (args
,from_tty
)
532 DENTER("mm_dettach()");
533 remove_breakpoints(); /* Just in case there were any left in */
534 out_msg_buf
->go_msg
.code
= GO
;
535 out_msg_buf
->go_msg
.length
= 0;
536 msg_send_serial(out_msg_buf
);
537 pop_target(); /* calls mm_close to do the real work */
538 DEXIT("mm_dettach()");
542 /*************************************************************** REMOTE_RESUME
543 ** Tell the remote machine to resume. */
546 mm_resume (step
, sig
)
549 DENTER("mm_resume()");
552 error ("Can't send signals to a remote MiniMon system.");
555 out_msg_buf
->step_msg
.code
= STEP
;
556 out_msg_buf
->step_msg
.length
= 1*4;
557 out_msg_buf
->step_msg
.count
= 1; /* step 1 instruction */
558 msg_send_serial(out_msg_buf
);
560 out_msg_buf
->go_msg
.code
= GO
;
561 out_msg_buf
->go_msg
.length
= 0;
562 msg_send_serial(out_msg_buf
);
565 DEXIT("mm_resume()");
568 /***************************************************************** REMOTE_WAIT
569 ** Wait until the remote machine stops, then return,
570 storing status in STATUS just as `wait' would. */
577 int old_timeout
= timeout
;
578 int old_immediate_quit
= immediate_quit
;
581 WSETEXIT ((*status
), 0);
584 /* wait for message to arrive. It should be:
585 - A HIF service request.
586 - A HIF exit service request.
588 - A CHANNEL1 request.
589 - a debugcore HALT message.
590 HIF services must be responded too, and while-looping continued.
591 If the target stops executing, mm_wait() should return.
593 timeout
= 0; /* Wait indefinetly for a message */
594 immediate_quit
= 1; /* Helps ability to QUIT */
597 while(msg_recv_serial(in_msg_buf
)) {
598 QUIT
; /* Let user quit if they want */
600 switch (in_msg_buf
->halt_msg
.code
)
603 i
= in_msg_buf
->hif_call_rtn_msg
.service_number
;
604 result
=service_HIF(in_msg_buf
);
605 if(i
== 1) /* EXIT */
608 printf("Warning: failure during HIF service %d\n", i
);
611 service_HIF(in_msg_buf
);
614 i
=in_msg_buf
->channel1_msg
.length
;
615 in_msg_buf
->channel1_msg
.data
[i
] = '\0';
616 printf("%s", in_msg_buf
->channel1_msg
.data
);
618 /* Send CHANNEL1_ACK message */
619 out_msg_buf
->channel1_ack_msg
.code
= CHANNEL1_ACK
;
620 out_msg_buf
->channel1_ack_msg
.length
= 0;
621 result
= msg_send_serial(out_msg_buf
);
630 /* FIXME, these printfs should not be here. This is a source level
632 if (in_msg_buf
->halt_msg
.trap_number
== 0)
633 { printf("Am290*0 received vector number %d (break point)\n",
634 in_msg_buf
->halt_msg
.trap_number
);
635 WSETSTOP ((*status
), SIGTRAP
);
637 else if (in_msg_buf
->halt_msg
.trap_number
== 1)
638 { printf("Am290*0 received vector number %d\n",
639 in_msg_buf
->halt_msg
.trap_number
);
640 WSETSTOP ((*status
), SIGBUS
);
642 else if (in_msg_buf
->halt_msg
.trap_number
== 3
643 || in_msg_buf
->halt_msg
.trap_number
== 4)
644 { printf("Am290*0 received vector number %d\n",
645 in_msg_buf
->halt_msg
.trap_number
);
646 WSETSTOP ((*status
), SIGFPE
);
648 else if (in_msg_buf
->halt_msg
.trap_number
== 5)
649 { printf("Am290*0 received vector number %d\n",
650 in_msg_buf
->halt_msg
.trap_number
);
651 WSETSTOP ((*status
), SIGILL
);
653 else if (in_msg_buf
->halt_msg
.trap_number
>= 6
654 && in_msg_buf
->halt_msg
.trap_number
<= 11)
655 { printf("Am290*0 received vector number %d\n",
656 in_msg_buf
->halt_msg
.trap_number
);
657 WSETSTOP ((*status
), SIGSEGV
);
659 else if (in_msg_buf
->halt_msg
.trap_number
== 12
660 || in_msg_buf
->halt_msg
.trap_number
== 13)
661 { printf("Am290*0 received vector number %d\n",
662 in_msg_buf
->halt_msg
.trap_number
);
663 WSETSTOP ((*status
), SIGILL
);
665 else if (in_msg_buf
->halt_msg
.trap_number
== 14)
666 { printf("Am290*0 received vector number %d\n",
667 in_msg_buf
->halt_msg
.trap_number
);
668 WSETSTOP ((*status
), SIGALRM
);
670 else if (in_msg_buf
->halt_msg
.trap_number
== 15)
671 WSETSTOP ((*status
), SIGTRAP
);
672 else if (in_msg_buf
->halt_msg
.trap_number
>= 16
673 && in_msg_buf
->halt_msg
.trap_number
<= 21)
674 { printf("Am290*0 received vector number %d\n",
675 in_msg_buf
->halt_msg
.trap_number
);
676 WSETSTOP ((*status
), SIGINT
);
678 else if (in_msg_buf
->halt_msg
.trap_number
== 22)
679 { printf("Am290*0 received vector number %d\n",
680 in_msg_buf
->halt_msg
.trap_number
);
681 WSETSTOP ((*status
), SIGILL
);
682 } /* BREAK message was sent */
683 else if (in_msg_buf
->halt_msg
.trap_number
== 75)
684 WSETSTOP ((*status
), SIGTRAP
);
687 WSETEXIT ((*status
), 0);
689 timeout
= old_timeout
; /* Restore original timeout value */
690 immediate_quit
= old_immediate_quit
;
695 /******************************************************* REMOTE_FETCH_REGISTERS
696 * Read a remote register 'regno'.
697 * If regno==-1 then read all the registers.
700 mm_fetch_registers (regno
)
706 fetch_register(regno
);
710 DENTER("mm_fetch_registers()");
713 out_msg_buf
->read_req_msg
.byte_count
= 4*1;
714 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
715 out_msg_buf
->read_req_msg
.address
= 1;
716 msg_send_serial(out_msg_buf
);
717 expect_msg(READ_ACK
,in_msg_buf
,1);
718 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
719 supply_register (GR1_REGNUM
, data_p
);
721 #if defined(GR64_REGNUM) /* Read gr64-127 */
722 /* Global Registers gr64-gr95 */
723 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
724 out_msg_buf
->read_req_msg
.length
= 4*3;
725 out_msg_buf
->read_req_msg
.byte_count
= 4*32;
726 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
727 out_msg_buf
->read_req_msg
.address
= 64;
728 msg_send_serial(out_msg_buf
);
729 expect_msg(READ_ACK
,in_msg_buf
,1);
730 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
732 for (regno
=GR64_REGNUM
; regno
<GR64_REGNUM
+32; regno
++) {
733 supply_register (regno
, data_p
++);
735 #endif /* GR64_REGNUM */
737 /* Global Registers gr96-gr127 */
738 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
739 out_msg_buf
->read_req_msg
.length
= 4*3;
740 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
741 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
742 out_msg_buf
->read_req_msg
.address
= 96;
743 msg_send_serial(out_msg_buf
);
744 expect_msg(READ_ACK
,in_msg_buf
,1);
745 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
747 for (regno
=GR96_REGNUM
; regno
<GR96_REGNUM
+32; regno
++) {
748 supply_register (regno
, data_p
++);
751 /* Local Registers */
752 out_msg_buf
->read_req_msg
.byte_count
= 4 * (128);
753 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
754 out_msg_buf
->read_req_msg
.address
= 0;
755 msg_send_serial(out_msg_buf
);
756 expect_msg(READ_ACK
,in_msg_buf
,1);
757 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
759 for (regno
=LR0_REGNUM
; regno
<LR0_REGNUM
+128; regno
++) {
760 supply_register (regno
, data_p
++);
763 /* Protected Special Registers */
764 out_msg_buf
->read_req_msg
.byte_count
= 4*15;
765 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
766 out_msg_buf
->read_req_msg
.address
= 0;
767 msg_send_serial( out_msg_buf
);
768 expect_msg(READ_ACK
,in_msg_buf
,1);
769 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
771 for (regno
=0; regno
<=14; regno
++) {
772 supply_register (SR_REGNUM(regno
), data_p
++);
774 if (USE_SHADOW_PC
) { /* Let regno_to_srnum() handle the register number */
775 fetch_register(NPC_REGNUM
);
776 fetch_register(PC_REGNUM
);
777 fetch_register(PC2_REGNUM
);
780 /* Unprotected Special Registers */
781 out_msg_buf
->read_req_msg
.byte_count
= 4*8;
782 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
783 out_msg_buf
->read_req_msg
.address
= 128;
784 msg_send_serial( out_msg_buf
);
785 expect_msg(READ_ACK
,in_msg_buf
,1);
786 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
788 for (regno
=128; regno
<=135; regno
++) {
789 supply_register (SR_REGNUM(regno
), data_p
++);
792 /* There doesn't seem to be any way to get these. */
795 supply_register (FPE_REGNUM
, &val
);
796 supply_register (INT_REGNUM
, &val
);
797 supply_register (FPS_REGNUM
, &val
);
798 supply_register (EXO_REGNUM
, &val
);
801 DEXIT("mm_fetch_registerS()");
805 /****************************************************** REMOTE_STORE_REGISTERS
806 * Store register regno into the target.
807 * If regno==-1 then store all the registers.
808 * Result is 0 for success, -1 for failure.
812 mm_store_registers (regno
)
818 return(store_register(regno
));
820 DENTER("mm_store_registers()");
823 out_msg_buf
->write_r_msg
.code
= WRITE_REQ
;
826 out_msg_buf
->write_r_msg
.byte_count
= 4*1;
827 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
828 out_msg_buf
->write_r_msg
.memory_space
= GLOBAL_REG
;
829 out_msg_buf
->write_r_msg
.address
= 1;
830 out_msg_buf
->write_r_msg
.data
[0] = read_register (GR1_REGNUM
);
832 msg_send_serial( out_msg_buf
);
833 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
837 #if defined(GR64_REGNUM)
838 /* Global registers gr64-gr95 */
839 out_msg_buf
->write_r_msg
.byte_count
= 4* (32);
840 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
841 out_msg_buf
->write_r_msg
.address
= 64;
843 for (regno
=GR64_REGNUM
; regno
<GR64_REGNUM
+32 ; regno
++)
845 out_msg_buf
->write_r_msg
.data
[regno
-GR64_REGNUM
] = read_register (regno
);
847 msg_send_serial(out_msg_buf
);
848 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
851 #endif /* GR64_REGNUM */
853 /* Global registers gr96-gr127 */
854 out_msg_buf
->write_r_msg
.byte_count
= 4* (32);
855 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
856 out_msg_buf
->write_r_msg
.address
= 96;
857 for (regno
=GR96_REGNUM
; regno
<GR96_REGNUM
+32 ; regno
++)
859 out_msg_buf
->write_r_msg
.data
[regno
-GR96_REGNUM
] = read_register (regno
);
861 msg_send_serial( out_msg_buf
);
862 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
866 /* Local Registers */
867 out_msg_buf
->write_r_msg
.memory_space
= LOCAL_REG
;
868 out_msg_buf
->write_r_msg
.byte_count
= 4*128;
869 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
870 out_msg_buf
->write_r_msg
.address
= 0;
872 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+128 ; regno
++)
874 out_msg_buf
->write_r_msg
.data
[regno
-LR0_REGNUM
] = read_register (regno
);
876 msg_send_serial( out_msg_buf
);
877 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
881 /* Protected Special Registers */
882 /* VAB through TMR */
883 out_msg_buf
->write_r_msg
.memory_space
= SPECIAL_REG
;
884 out_msg_buf
->write_r_msg
.byte_count
= 4* 10;
885 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
886 out_msg_buf
->write_r_msg
.address
= 0;
887 for (regno
= 0 ; regno
<=9 ; regno
++) /* VAB through TMR */
888 out_msg_buf
->write_r_msg
.data
[regno
] = read_register (SR_REGNUM(regno
));
889 msg_send_serial( out_msg_buf
);
890 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
894 /* PC0, PC1, PC2 possibly as shadow registers */
895 out_msg_buf
->write_r_msg
.byte_count
= 4* 3;
896 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
897 for (regno
=10 ; regno
<=12 ; regno
++) /* LRU and MMU */
898 out_msg_buf
->write_r_msg
.data
[regno
-10] = read_register (SR_REGNUM(regno
));
900 out_msg_buf
->write_r_msg
.address
= 20; /* SPC0 */
902 out_msg_buf
->write_r_msg
.address
= 10; /* PC0 */
903 msg_send_serial( out_msg_buf
);
904 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
909 out_msg_buf
->write_r_msg
.byte_count
= 4* 2;
910 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
911 out_msg_buf
->write_r_msg
.address
= 13;
912 for (regno
=13 ; regno
<=14 ; regno
++) /* LRU and MMU */
913 out_msg_buf
->write_r_msg
.data
[regno
-13] = read_register (SR_REGNUM(regno
));
914 msg_send_serial( out_msg_buf
);
915 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
919 /* Unprotected Special Registers */
920 out_msg_buf
->write_r_msg
.byte_count
= 4*8;
921 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
922 out_msg_buf
->write_r_msg
.address
= 128;
923 for (regno
= 128 ; regno
<=135 ; regno
++)
924 out_msg_buf
->write_r_msg
.data
[regno
-128] = read_register(SR_REGNUM(regno
));
925 msg_send_serial( out_msg_buf
);
926 if (!expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
930 registers_changed ();
931 DEXIT("mm_store_registers()");
935 /*************************************************** REMOTE_PREPARE_TO_STORE */
936 /* Get ready to modify the registers array. On machines which store
937 individual registers, this doesn't need to do anything. On machines
938 which store all the registers in one fell swoop, this makes sure
939 that registers contains all the registers from the program being
943 mm_prepare_to_store ()
945 /* Do nothing, since we can store individual regs */
948 /******************************************************* REMOTE_XFER_MEMORY */
953 #if defined(KERNEL_DEBUGGING)
954 /* Check for a virtual address in the kernel */
955 /* Assume physical address of ublock is in paddr_u register */
956 /* FIXME: doesn't work for user virtual addresses */
957 if (addr
>= UVADDR
) {
958 /* PADDR_U register holds the physical address of the ublock */
959 CORE_ADDR i
= (CORE_ADDR
)read_register(PADDR_U_REGNUM
);
960 return(i
+ addr
- (CORE_ADDR
)UVADDR
);
969 /******************************************************* REMOTE_FILES_INFO */
973 printf ("\tAttached to %s at %d baud and running program %s.\n",
974 dev_name
, baudrate
, prog_name
);
977 /************************************************* REMOTE_INSERT_BREAKPOINT */
979 mm_insert_breakpoint (addr
, contents_cache
)
981 char *contents_cache
;
983 DENTER("mm_insert_breakpoint()");
984 out_msg_buf
->bkpt_set_msg
.code
= BKPT_SET
;
985 out_msg_buf
->bkpt_set_msg
.length
= 4*4;
986 out_msg_buf
->bkpt_set_msg
.memory_space
= I_MEM
;
987 out_msg_buf
->bkpt_set_msg
.bkpt_addr
= (ADDR32
) addr
;
988 out_msg_buf
->bkpt_set_msg
.pass_count
= 1;
989 out_msg_buf
->bkpt_set_msg
.bkpt_type
= -1; /* use illop for 29000 */
990 msg_send_serial( out_msg_buf
);
991 if (expect_msg(BKPT_SET_ACK
,in_msg_buf
,1)) {
992 DEXIT("mm_insert_breakpoint() success");
993 return 0; /* Success */
995 DEXIT("mm_insert_breakpoint() failure");
996 return 1; /* Failure */
1000 /************************************************* REMOTE_DELETE_BREAKPOINT */
1002 mm_remove_breakpoint (addr
, contents_cache
)
1004 char *contents_cache
;
1006 DENTER("mm_remove_breakpoint()");
1007 out_msg_buf
->bkpt_rm_msg
.code
= BKPT_RM
;
1008 out_msg_buf
->bkpt_rm_msg
.length
= 4*3;
1009 out_msg_buf
->bkpt_rm_msg
.memory_space
= I_MEM
;
1010 out_msg_buf
->bkpt_rm_msg
.bkpt_addr
= (ADDR32
) addr
;
1011 msg_send_serial( out_msg_buf
);
1012 if (expect_msg(BKPT_RM_ACK
,in_msg_buf
,1)) {
1013 DEXIT("mm_remove_breakpoint()");
1014 return 0; /* Success */
1016 DEXIT("mm_remove_breakpoint()");
1017 return 1; /* Failure */
1022 /******************************************************* REMOTE_KILL */
1024 mm_kill(arg
,from_tty
)
1030 DENTER("mm_kill()");
1031 #if defined(KERNEL_DEBUGGING)
1032 /* We don't ever kill the kernel */
1034 printf("Kernel not killed, but left in current state.\n");
1035 printf("Use detach to leave kernel running.\n");
1038 out_msg_buf
->break_msg
.code
= BREAK
;
1039 out_msg_buf
->bkpt_set_msg
.length
= 4*0;
1040 expect_msg(HALT
,in_msg_buf
,from_tty
);
1042 printf("Target has been stopped.");
1043 printf("Would you like to do a hardware reset (y/n) [n] ");
1045 if (buf
[0] == 'y') {
1046 out_msg_buf
->reset_msg
.code
= RESET
;
1047 out_msg_buf
->bkpt_set_msg
.length
= 4*0;
1048 expect_msg(RESET_ACK
,in_msg_buf
,from_tty
);
1049 printf("Target has been reset.");
1059 /***************************************************************************/
1061 * Load a program into the target.
1064 mm_load(arg_string
,from_tty
)
1070 #if defined(KERNEL_DEBUGGING)
1071 printf("The kernel had better be loaded already! Loading not done.\n");
1073 if (arg_string
== 0)
1074 error ("The load command takes a file name");
1076 arg_string
= tilde_expand (arg_string
);
1077 make_cleanup (free
, arg_string
);
1080 error("File loading is not yet supported for MiniMon.");
1081 /* FIXME, code to load your file here... */
1082 /* You may need to do an init_target_mm() */
1083 /* init_target_mm(?,?,?,?,?,?,?,?); */
1085 /* (void) symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
1090 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1091 ** Copy LEN bytes of data from debugger memory at MYADDR
1092 to inferior's memory at MEMADDR. Returns number of bytes written. */
1094 mm_write_inferior_memory (memaddr
, myaddr
, len
)
1101 /* DENTER("mm_write_inferior_memory()"); */
1102 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1103 out_msg_buf
->write_req_msg
.memory_space
= mm_memory_space(memaddr
);
1106 while (nwritten
< len
) {
1107 int num_to_write
= len
- nwritten
;
1108 if (num_to_write
> MAXDATA
) num_to_write
= MAXDATA
;
1109 for (i
=0 ; i
< num_to_write
; i
++)
1110 out_msg_buf
->write_req_msg
.data
[i
] = myaddr
[i
+nwritten
];
1111 out_msg_buf
->write_req_msg
.byte_count
= num_to_write
;
1112 out_msg_buf
->write_req_msg
.length
= 3*4 + num_to_write
;
1113 out_msg_buf
->write_req_msg
.address
= memaddr
+ nwritten
;
1114 msg_send_serial(out_msg_buf
);
1116 if (expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
1117 nwritten
+= in_msg_buf
->write_ack_msg
.byte_count
;
1122 /* DEXIT("mm_write_inferior_memory()"); */
1126 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1127 ** Read LEN bytes from inferior memory at MEMADDR. Put the result
1128 at debugger address MYADDR. Returns number of bytes read. */
1130 mm_read_inferior_memory(memaddr
, myaddr
, len
)
1137 /* DENTER("mm_read_inferior_memory()"); */
1138 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1139 out_msg_buf
->read_req_msg
.memory_space
= mm_memory_space(memaddr
);
1142 while (nread
< len
) {
1143 int num_to_read
= (len
- nread
);
1144 if (num_to_read
> MAXDATA
) num_to_read
= MAXDATA
;
1145 out_msg_buf
->read_req_msg
.byte_count
= num_to_read
;
1146 out_msg_buf
->read_req_msg
.length
= 3*4 + num_to_read
;
1147 out_msg_buf
->read_req_msg
.address
= memaddr
+ nread
;
1148 msg_send_serial(out_msg_buf
);
1150 if (expect_msg(READ_ACK
,in_msg_buf
,1)) {
1151 for (i
=0 ; i
<in_msg_buf
->read_ack_msg
.byte_count
; i
++)
1152 myaddr
[i
+nread
] = in_msg_buf
->read_ack_msg
.data
[i
];
1153 nread
+= in_msg_buf
->read_ack_msg
.byte_count
;
1161 /* FIXME! Merge these two. */
1163 mm_xfer_inferior_memory (memaddr
, myaddr
, len
, write
)
1170 memaddr
= translate_addr(memaddr
);
1173 return mm_write_inferior_memory (memaddr
, myaddr
, len
);
1175 return mm_read_inferior_memory (memaddr
, myaddr
, len
);
1179 /********************************************************** MSG_SEND_SERIAL
1180 ** This function is used to send a message over the
1183 ** If the message is successfully sent, a zero is
1184 ** returned. If the message was not sendable, a -1
1185 ** is returned. This function blocks. That is, it
1186 ** does not return until the message is completely
1187 ** sent, or until an error is encountered.
1192 msg_send_serial(msg_ptr
)
1193 union msg_t
*msg_ptr
;
1200 /* Send message header */
1202 message_size
= msg_ptr
->generic_msg
.length
+ (2 * sizeof(INT32
));
1204 c
= *((char *)msg_ptr
+byte_count
);
1205 result
= write(mm_desc
, &c
, 1);
1207 byte_count
= byte_count
+ 1;
1209 } while ((byte_count
< message_size
) );
1212 } /* end msg_send_serial() */
1214 /********************************************************** MSG_RECV_SERIAL
1215 ** This function is used to receive a message over a
1218 ** If the message is waiting in the buffer, a zero is
1219 ** returned and the buffer pointed to by msg_ptr is filled
1220 ** in. If no message was available, a -1 is returned.
1221 ** If timeout==0, wait indefinetly for a character.
1226 msg_recv_serial(msg_ptr
)
1227 union msg_t
*msg_ptr
;
1229 static INT32 length
=0;
1230 static INT32 byte_count
=0;
1233 if(msg_ptr
== 0) /* re-sync request */
1237 /* The timeout here is the prevailing timeout set with VTIME */
1238 ->"timeout==0 semantics not supported"
1239 read(mm_desc
, in_buf
, BUFER_SIZE
);
1242 read(mm_desc
, in_buf
, BUFER_SIZE
);
1247 /* Receive message */
1249 /* Timeout==0, help support the mm_wait() routine */
1250 ->"timeout==0 semantics not supported (and its nice if they are)"
1251 result
= read(mm_desc
, &c
, 1);
1254 result
= read(mm_desc
, &c
, 1);
1258 if (errno
== EINTR
) {
1259 error ("Timeout reading from remote system.");
1261 perror_with_name ("remote");
1262 } else if (result
== 1) {
1263 *((char *)msg_ptr
+byte_count
) = c
;
1264 byte_count
= byte_count
+ 1;
1267 /* Message header received. Save message length. */
1268 if (byte_count
== (2 * sizeof(INT32
)))
1269 length
= msg_ptr
->generic_msg
.length
;
1271 if (byte_count
>= (length
+ (2 * sizeof(INT32
)))) {
1272 /* Message received */
1278 } /* end msg_recv_serial() */
1280 /********************************************************************* KBD_RAW
1281 ** This function is used to put the keyboard in "raw"
1282 ** mode for BSD Unix. The original status is saved
1283 ** so that it may be restored later.
1292 /* Get keyboard termio (to save to restore original modes) */
1294 result
= ioctl(0, TCGETA
, &kbd_tbuf
);
1296 result
= ioctl(0, TIOCGETP
, &kbd_tbuf
);
1301 /* Get keyboard TERMINAL (for modification) */
1303 result
= ioctl(0, TCGETA
, &tbuf
);
1305 result
= ioctl(0, TIOCGETP
, &tbuf
);
1310 /* Set up new parameters */
1312 tbuf
.c_iflag
= tbuf
.c_iflag
&
1313 ~(INLCR
| ICRNL
| IUCLC
| ISTRIP
| IXON
| BRKINT
);
1314 tbuf
.c_lflag
= tbuf
.c_lflag
& ~(ICANON
| ISIG
| ECHO
);
1315 tbuf
.c_cc
[4] = 0; /* MIN */
1316 tbuf
.c_cc
[5] = 0; /* TIME */
1318 /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1319 tbuf
.sg_flags
|= RAW
;
1320 tbuf
.sg_flags
|= ANYP
;
1321 tbuf
.sg_flags
&= ~ECHO
;
1324 /* Set keyboard termio to new mode (RAW) */
1326 result
= ioctl(0, TCSETAF
, &tbuf
);
1328 result
= ioctl(0, TIOCSETP
, &tbuf
);
1334 } /* end kbd_raw() */
1338 /***************************************************************** KBD_RESTORE
1339 ** This function is used to put the keyboard back in the
1340 ** mode it was in before kbk_raw was called. Note that
1341 ** kbk_raw() must have been called at least once before
1342 ** kbd_restore() is called.
1349 /* Set keyboard termio to original mode */
1351 result
= ioctl(0, TCSETAF
, &kbd_tbuf
);
1353 result
= ioctl(0, TIOCGETP
, &kbd_tbuf
);
1360 } /* end kbd_cooked() */
1363 /*****************************************************************************/
1364 /* Fetch a single register indicatated by 'regno'.
1365 * Returns 0/-1 on success/failure.
1368 fetch_register (regno
)
1372 DENTER("mm_fetch_register()");
1373 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1374 out_msg_buf
->read_req_msg
.length
= 4*3;
1375 out_msg_buf
->read_req_msg
.byte_count
= 4;
1377 if (regno
== GR1_REGNUM
)
1378 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1379 out_msg_buf
->read_req_msg
.address
= 1;
1381 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1382 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1383 out_msg_buf
->read_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1385 #if defined(GR64_REGNUM)
1386 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32 )
1387 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1388 out_msg_buf
->read_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1390 #endif /* GR64_REGNUM */
1391 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1392 { out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
1393 out_msg_buf
->read_req_msg
.address
= (regno
- LR0_REGNUM
);
1395 else if (regno
>=FPE_REGNUM
&& regno
<=EXO_REGNUM
)
1397 supply_register(160 + (regno
- FPE_REGNUM
),&val
);
1398 return 0; /* Pretend Success */
1401 { out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
1402 out_msg_buf
->read_req_msg
.address
= regnum_to_srnum(regno
);
1405 msg_send_serial(out_msg_buf
);
1407 if (expect_msg(READ_ACK
,in_msg_buf
,1)) {
1408 supply_register (regno
, &(in_msg_buf
->read_r_ack_msg
.data
[0]));
1413 DEXIT("mm_fetch_register()");
1416 /*****************************************************************************/
1417 /* Store a single register indicated by 'regno'.
1418 * Returns 0/-1 on success/failure.
1421 store_register (regno
)
1426 DENTER("store_register()");
1427 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1428 out_msg_buf
->write_req_msg
.length
= 4*4;
1429 out_msg_buf
->write_req_msg
.byte_count
= 4;
1430 out_msg_buf
->write_r_msg
.data
[0] = read_register (regno
);
1432 if (regno
== GR1_REGNUM
)
1433 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1434 out_msg_buf
->write_req_msg
.address
= 1;
1435 /* Setting GR1 changes the numbers of all the locals, so invalidate the
1436 * register cache. Do this *after* calling read_register, because we want
1437 * read_register to return the value that write_register has just stuffed
1438 * into the registers array, not the value of the register fetched from
1441 registers_changed ();
1443 #if defined(GR64_REGNUM)
1444 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32 )
1445 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1446 out_msg_buf
->write_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1448 #endif /* GR64_REGNUM */
1449 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1450 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1451 out_msg_buf
->write_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1453 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1454 { out_msg_buf
->write_req_msg
.memory_space
= LOCAL_REG
;
1455 out_msg_buf
->write_req_msg
.address
= (regno
- LR0_REGNUM
);
1457 else if (regno
>=FPE_REGNUM
&& regno
<=EXO_REGNUM
)
1459 return 0; /* Pretend Success */
1461 else /* An unprotected or protected special register */
1462 { out_msg_buf
->write_req_msg
.memory_space
= SPECIAL_REG
;
1463 out_msg_buf
->write_req_msg
.address
= regnum_to_srnum(regno
);
1466 msg_send_serial(out_msg_buf
);
1468 if (expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
1473 DEXIT("store_register()");
1476 /****************************************************************************/
1478 * Convert a gdb special register number to a 29000 special register number.
1481 regnum_to_srnum(regno
)
1485 case VAB_REGNUM
: return(0);
1486 case OPS_REGNUM
: return(1);
1487 case CPS_REGNUM
: return(2);
1488 case CFG_REGNUM
: return(3);
1489 case CHA_REGNUM
: return(4);
1490 case CHD_REGNUM
: return(5);
1491 case CHC_REGNUM
: return(6);
1492 case RBP_REGNUM
: return(7);
1493 case TMC_REGNUM
: return(8);
1494 case TMR_REGNUM
: return(9);
1495 case NPC_REGNUM
: return(USE_SHADOW_PC
? (20) : (10));
1496 case PC_REGNUM
: return(USE_SHADOW_PC
? (21) : (11));
1497 case PC2_REGNUM
: return(USE_SHADOW_PC
? (22) : (12));
1498 case MMU_REGNUM
: return(13);
1499 case LRU_REGNUM
: return(14);
1500 case IPC_REGNUM
: return(128);
1501 case IPA_REGNUM
: return(129);
1502 case IPB_REGNUM
: return(130);
1503 case Q_REGNUM
: return(131);
1504 case ALU_REGNUM
: return(132);
1505 case BP_REGNUM
: return(133);
1506 case FC_REGNUM
: return(134);
1507 case CR_REGNUM
: return(135);
1508 case FPE_REGNUM
: return(160);
1509 case INT_REGNUM
: return(161);
1510 case FPS_REGNUM
: return(162);
1511 case EXO_REGNUM
:return(164);
1513 return(255); /* Failure ? */
1516 /****************************************************************************/
1518 * Initialize the target debugger (minimon only).
1521 init_target_mm(tstart
,tend
,dstart
,dend
,entry
,ms_size
,rs_size
,arg_start
)
1522 ADDR32 tstart
,tend
,dstart
,dend
,entry
;
1523 INT32 ms_size
,rs_size
;
1526 out_msg_buf
->init_msg
.code
= INIT
;
1527 out_msg_buf
->init_msg
.length
= sizeof(struct init_msg_t
)-2*sizeof(INT32
);
1528 out_msg_buf
->init_msg
.text_start
= tstart
;
1529 out_msg_buf
->init_msg
.text_end
= tend
;
1530 out_msg_buf
->init_msg
.data_start
= dstart
;
1531 out_msg_buf
->init_msg
.data_end
= dend
;
1532 out_msg_buf
->init_msg
.entry_point
= entry
;
1533 out_msg_buf
->init_msg
.mem_stack_size
= ms_size
;
1534 out_msg_buf
->init_msg
.reg_stack_size
= rs_size
;
1535 out_msg_buf
->init_msg
.arg_start
= arg_start
;
1536 msg_send_serial(out_msg_buf
);
1537 expect_msg(INIT_ACK
,in_msg_buf
,1);
1539 /****************************************************************************/
1541 * Return a pointer to a string representing the given message code.
1542 * Not all messages are represented here, only the ones that we expect
1543 * to be called with.
1549 static char cbuf
[32];
1552 case BKPT_SET_ACK
: sprintf(cbuf
,"%s (%d)","BKPT_SET_ACK",code
); break;
1553 case BKPT_RM_ACK
: sprintf(cbuf
,"%s (%d)","BKPT_RM_ACK",code
); break;
1554 case INIT_ACK
: sprintf(cbuf
,"%s (%d)","INIT_ACK",code
); break;
1555 case READ_ACK
: sprintf(cbuf
,"%s (%d)","READ_ACK",code
); break;
1556 case WRITE_ACK
: sprintf(cbuf
,"%s (%d)","WRITE_ACK",code
); break;
1557 case ERROR
: sprintf(cbuf
,"%s (%d)","ERROR",code
); break;
1558 case HALT
: sprintf(cbuf
,"%s (%d)","HALT",code
); break;
1559 default: sprintf(cbuf
,"UNKNOWN (%d)",code
); break;
1563 /****************************************************************************/
1565 * Selected (not all of them) error codes that we might get.
1571 static char cbuf
[50];
1574 case EMFAIL
: return("EMFAIL: unrecoverable error");
1575 case EMBADADDR
: return("EMBADADDR: Illegal address");
1576 case EMBADREG
: return("EMBADREG: Illegal register ");
1577 case EMACCESS
: return("EMACCESS: Could not access memory");
1578 case EMBADMSG
: return("EMBADMSG: Unknown message type");
1579 case EMMSG2BIG
: return("EMMSG2BIG: Message to large");
1580 case EMNOSEND
: return("EMNOSEND: Could not send message");
1581 case EMNORECV
: return("EMNORECV: Could not recv message");
1582 case EMRESET
: return("EMRESET: Could not RESET target");
1583 case EMCONFIG
: return("EMCONFIG: Could not get target CONFIG");
1584 case EMSTATUS
: return("EMSTATUS: Could not get target STATUS");
1585 case EMREAD
: return("EMREAD: Could not READ target memory");
1586 case EMWRITE
: return("EMWRITE: Could not WRITE target memory");
1587 case EMBKPTSET
: return("EMBKPTSET: Could not set breakpoint");
1588 case EMBKPTRM
: return("EMBKPTRM: Could not remove breakpoint");
1589 case EMBKPTSTAT
:return("EMBKPTSTAT: Could not get breakpoint status");
1590 case EMBKPTNONE
:return("EMBKPTNONE: All breakpoints in use");
1591 case EMBKPTUSED
:return("EMBKPTUSED: Breakpoints already in use");
1592 case EMINIT
: return("EMINIT: Could not init target memory");
1593 case EMGO
: return("EMGO: Could not start execution");
1594 case EMSTEP
: return("EMSTEP: Could not single step");
1595 case EMBREAK
: return("EMBREAK: Could not BREAK");
1596 case EMCOMMERR
: return("EMCOMMERR: Communication error");
1597 default: sprintf(cbuf
,"error number %d",code
); break;
1602 /****************************************************************************/
1604 * Receive a message and expect it to be of type msgcode.
1605 * Returns 0/1 on failure/success.
1608 expect_msg(msgcode
,msg_buf
,from_tty
)
1609 INT32 msgcode
; /* Msg code we expect */
1610 union msg_t
*msg_buf
; /* Where to put the message received */
1611 int from_tty
; /* Print message on error if non-zero */
1613 /* DENTER("expect_msg()"); */
1615 while(msg_recv_serial(msg_buf
) && (retries
++<MAX_RETRIES
));
1616 if (retries
>= MAX_RETRIES
) {
1617 printf("Expected msg %s, ",msg_str(msgcode
));
1618 printf("no message received!\n");
1619 /* DEXIT("expect_msg() failure"); */
1620 return(0); /* Failure */
1623 if (msg_buf
->generic_msg
.code
!= msgcode
) {
1625 printf("Expected msg %s, ",msg_str(msgcode
));
1626 printf("got msg %s\n",msg_str(msg_buf
->generic_msg
.code
));
1627 if (msg_buf
->generic_msg
.code
== ERROR
)
1628 printf("%s\n",error_msg_str(msg_buf
->error_msg
.error_code
));
1630 /* DEXIT("expect_msg() failure"); */
1631 return(0); /* Failure */
1633 /* DEXIT("expect_msg() success"); */
1634 return(1); /* Success */
1636 /****************************************************************************/
1638 * Determine the MiniMon memory space qualifier based on the addr.
1639 * FIXME: Can't distinguis I_ROM/D_ROM.
1640 * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1643 mm_memory_space(addr
)
1646 ADDR32 tstart
= target_config
.I_mem_start
;
1647 ADDR32 tend
= tstart
+ target_config
.I_mem_size
;
1648 ADDR32 dstart
= target_config
.D_mem_start
;
1649 ADDR32 dend
= tstart
+ target_config
.D_mem_size
;
1650 ADDR32 rstart
= target_config
.ROM_start
;
1651 ADDR32 rend
= tstart
+ target_config
.ROM_size
;
1653 if (((ADDR32
)addr
>= tstart
) && ((ADDR32
)addr
< tend
)) {
1655 } else if (((ADDR32
)addr
>= dstart
) && ((ADDR32
)addr
< dend
)) {
1657 } else if (((ADDR32
)addr
>= rstart
) && ((ADDR32
)addr
< rend
)) {
1658 /* FIXME: how do we determine between D_ROM and I_ROM */
1660 } else /* FIXME: what do me do now? */
1661 return D_MEM
; /* Hmmm! */
1664 /****************************************************************************/
1666 * Define the target subroutine names
1668 struct target_ops mm_ops
= {
1669 "minimon", "Remote AMD/Minimon target",
1670 "Remote debug an AMD 290*0 using the MiniMon dbg core on the target",
1672 mm_attach
, mm_detach
, mm_resume
, mm_wait
,
1673 mm_fetch_registers
, mm_store_registers
,
1674 mm_prepare_to_store
, 0, 0, /* conv_to, conv_from */
1675 mm_xfer_inferior_memory
,
1677 mm_insert_breakpoint
, mm_remove_breakpoint
, /* Breakpoints */
1678 0, 0, 0, 0, 0, /* Terminal handling */
1679 mm_kill
, /* FIXME, kill */
1681 0, /* lookup_symbol */
1682 mm_create_inferior
, /* create_inferior */
1683 mm_mourn
, /* mourn_inferior FIXME */
1684 process_stratum
, 0, /* next */
1685 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1686 0,0, /* sections, sections_end */
1687 OPS_MAGIC
, /* Always the last thing */
1691 _initialize_remote_mm()
1693 add_target (&mm_ops
);
1696 #ifdef NO_HIF_SUPPORT
1700 return(0); /* Emulate a failure */