1 /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
2 Copyright (C) 1990, 1991 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
46 /* Offset of member MEMBER in a struct of type TYPE. */
47 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
49 /* #define DEBUG 1 /* */
51 # define DENTER(NAME) (printf("Entering %s\n",NAME), fflush(stdout))
52 # define DEXIT(NAME) (printf("Exiting %s\n",NAME), fflush(stdout))
58 #define DRAIN_INPUT() (msg_recv_serial((union msg_t*)0))
60 extern int stop_soon_quietly
; /* for wait_for_inferior */
62 extern struct value
*call_function_by_hand();
64 static void mm_resume();
65 static void mm_fetch_registers ();
66 static int fetch_register ();
67 static int mm_store_registers ();
68 static int store_register ();
69 static int regnum_to_srnum();
70 static void mm_close ();
71 static char* msg_str();
72 static char* error_msg_str();
73 static int expect_msg();
74 static void init_target_mm();
75 static int mm_memory_space();
80 #define TYPE_UNKNOWN 0
84 static char *processor_name
[] = { "Unknown", "A29000", "A29030", "A29050" };
85 static int processor_type
=TYPE_UNKNOWN
;
86 #define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
87 #define USE_SHADOW_PC ((processor_type == TYPE_A29050) && FREEZE_MODE)
89 #define LLOG_FILE "minimon.log"
90 #if defined (LOG_FILE)
95 * Size of message buffers. I couldn't get memory reads to work when
96 * the byte_count was larger than 512 (it may be a baud rate problem).
98 #define BUFER_SIZE 512
100 * Size of data area in message buffer on the TARGET (remote system).
102 #define MAXDATA_T (target_config.max_msg_size - \
103 offsetof(struct write_r_msg_t,data[0]))
105 * Size of data area in message buffer on the HOST (gdb).
107 #define MAXDATA_H (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
109 * Defined as the minimum size of data areas of the two message buffers
111 #define MAXDATA (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
113 static char out_buf
[BUFER_SIZE
];
114 static char in_buf
[BUFER_SIZE
];
116 int msg_recv_serial();
117 int msg_send_serial();
119 #define MAX_RETRIES 5000
120 extern struct target_ops mm_ops
; /* Forward declaration */
121 struct config_msg_t target_config
; /* HIF needs this */
122 union msg_t
*out_msg_buf
= (union msg_t
*)out_buf
;
123 union msg_t
*in_msg_buf
= (union msg_t
*)in_buf
;
125 static int timeout
= 5;
127 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
128 mm_open knows that we don't have a file open when the program
132 /* stream which is fdopen'd from mm_desc. Only valid when
136 /* Called when SIGALRM signal sent due to alarm() timeout. */
141 # define volatile /**/
144 volatile int n_alarms
;
151 printf ("mm_timer called\n");
155 #endif /* HAVE_TERMIO */
157 /* malloc'd name of the program on the remote system. */
158 static char *prog_name
= NULL
;
161 /* Number of SIGTRAPs we need to simulate. That is, the next
162 NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
163 SIGTRAP without actually waiting for anything. */
165 /**************************************************** REMOTE_CREATE_INFERIOR */
166 /* This is called not only when we first attach, but also when the
167 user types "run" after having attached. */
169 mm_create_inferior (execfile
, args
, env
)
174 #define MAX_TOKENS 25
175 #define BUFFER_SIZE 256
178 char *token
[MAX_TOKENS
];
179 char cmd_line
[BUFFER_SIZE
];
181 DENTER("mm_create_inferior()");
184 error ("Can't pass arguments to remote mm process (yet).");
186 if (execfile
== 0 /* || exec_bfd == 0 */ )
187 error ("No exec file specified");
190 printf("Minimon not open yet.\n");
194 /* On ultra3 (NYU) we assume the kernel is already running so there is
196 FIXME: Fixed required here -> load your program, possibly with mm_load().
198 printf_filtered ("\n\
199 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
201 /* We will get a task spawn event immediately. */
202 #ifdef NOTDEF /* start_remote() now does a wait without a resume
206 init_wait_for_inferior ();
207 clear_proceed_status ();
208 stop_soon_quietly
= 1;
212 DEXIT("mm_create_inferior()");
214 /**************************************************** REMOTE_MOURN_INFERIOR */
218 DENTER("mm_mourn()");
219 pop_target (); /* Pop back to no-child state */
220 generic_mourn_inferior ();
224 /********************************************************************** damn_b
226 /* Translate baud rates from integers to damn B_codes. Unix should
227 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
236 static struct {int rate
, damn_b
;} baudtab
[] = {
256 static int damn_b (rate
)
261 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
262 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
263 return B38400
; /* Random */
267 /***************************************************************** REMOTE_OPEN
268 ** Open a connection to remote minimon.
269 NAME is the filename used for communication, then a space,
271 'target adapt /dev/ttya 9600 [prognam]' for example.
274 static char *dev_name
;
277 mm_open (name
, from_tty
)
287 /* Find the first whitespace character, it separates dev_name from
290 *p
!= '\0' && !isspace (*p
); p
++)
294 error ("Usage : <command> <serial-device> <baud-rate> [progname]");
295 dev_name
= (char*)malloc (p
- name
+ 1);
296 strncpy (dev_name
, name
, p
- name
);
297 dev_name
[p
- name
] = '\0';
299 /* Skip over the whitespace after dev_name */
300 for (; isspace (*p
); p
++)
303 if (1 != sscanf (p
, "%d ", &baudrate
))
306 /* Skip the number and then the spaces */
307 for (; isdigit (*p
); p
++)
309 for (; isspace (*p
); p
++)
312 if (prog_name
!= NULL
)
314 prog_name
= savestring (p
, strlen (p
));
320 mm_desc
= open (dev_name
, O_RDWR
);
322 perror_with_name (dev_name
);
323 ioctl (mm_desc
, TIOCGETP
, &sg
);
325 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
326 sg
.c_cc
[VTIME
] = timeout
* 10;
327 sg
.c_lflag
&= ~(ICANON
| ECHO
);
328 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
330 sg
.sg_ispeed
= damn_b (baudrate
);
331 sg
.sg_ospeed
= damn_b (baudrate
);
334 sg
.sg_flags
&= ~ECHO
;
338 ioctl (mm_desc
, TIOCSETP
, &sg
);
339 mm_stream
= fdopen (mm_desc
, "r+");
341 push_target (&mm_ops
);
344 #ifndef NO_SIGINTERRUPT
345 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
347 if (siginterrupt (SIGALRM
, 1) != 0)
348 perror ("mm_open: error in siginterrupt");
351 /* Set up read timeout timer. */
352 if ((void (*)) signal (SIGALRM
, mm_timer
) == (void (*)) -1)
353 perror ("mm_open: error in signal");
356 #if defined (LOG_FILE)
357 log_file
= fopen (LOG_FILE
, "w");
358 if (log_file
== NULL
)
359 perror_with_name (LOG_FILE
);
362 ** Initialize target configuration structure (global)
365 out_msg_buf
->config_req_msg
.code
= CONFIG_REQ
;
366 out_msg_buf
->config_req_msg
.length
= 4*0;
367 msg_send_serial(out_msg_buf
); /* send config request message */
369 expect_msg(CONFIG
,in_msg_buf
,1);
371 /* Determine the processor revision level */
372 /* FIXME: this code is the same as in remote-adapt.c */
373 prl
= (unsigned int)read_register(CFG_REGNUM
) >> 24;
375 processor_type
= TYPE_A29000
;
376 } else if ((prl
&0xf0) == 0x40) { /* 29030 = 0x4* */
377 processor_type
= TYPE_A29030
;
378 fprintf_filtered(stderr
,"WARNING: debugging of A29030 not tested.\n");
379 } else if ((prl
&0xf0) == 0x20) { /* 29050 = 0x2* */
380 processor_type
= TYPE_A29050
;
381 fprintf_filtered(stderr
,"WARNING: debugging of A29050 not tested.\n");
383 processor_type
= TYPE_UNKNOWN
;
384 fprintf_filtered(stderr
,"WARNING: processor type unknown.\n");
387 /* Print out some stuff, letting the user now what's going on */
388 printf_filtered("Remote debugging on an %s connect to MiniMon via %s.\n",
389 processor_name
[processor_type
],dev_name
);
390 /* FIXME: can this restriction be removed? */
391 printf_filtered("Remote debugging using virtual addresses works only\n");
392 printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n")
394 if (processor_type
!= TYPE_A29050
) {
395 fprintf_filtered(stderr
,
396 "Freeze-mode debugging not available, and can only be done on an A29050.\n");
399 target_config
.code
= CONFIG
;
400 target_config
.length
= 0;
401 target_config
.processor_id
= in_msg_buf
->config_msg
.processor_id
;
402 target_config
.version
= in_msg_buf
->config_msg
.version
;
403 target_config
.I_mem_start
= in_msg_buf
->config_msg
.I_mem_start
;
404 target_config
.I_mem_size
= in_msg_buf
->config_msg
.I_mem_size
;
405 target_config
.D_mem_start
= in_msg_buf
->config_msg
.D_mem_start
;
406 target_config
.D_mem_size
= in_msg_buf
->config_msg
.D_mem_size
;
407 target_config
.ROM_start
= in_msg_buf
->config_msg
.ROM_start
;
408 target_config
.ROM_size
= in_msg_buf
->config_msg
.ROM_size
;
409 target_config
.max_msg_size
= in_msg_buf
->config_msg
.max_msg_size
;
410 target_config
.max_bkpts
= in_msg_buf
->config_msg
.max_bkpts
;
411 target_config
.coprocessor
= in_msg_buf
->config_msg
.coprocessor
;
412 target_config
.reserved
= in_msg_buf
->config_msg
.reserved
;
414 printf("Connected to MiniMON :\n");
415 printf(" Debugcore version %d.%d\n",
416 0x0f & (target_config
.version
>> 4),
417 0x0f & (target_config
.version
) );
418 printf(" Configuration version %d.%d\n",
419 0x0f & (target_config
.version
>> 12),
420 0x0f & (target_config
.version
>> 8) );
421 printf(" Message system version %d.%d\n",
422 0x0f & (target_config
.version
>> 20),
423 0x0f & (target_config
.version
>> 16) );
424 printf(" Communication driver version %d.%d\n",
425 0x0f & (target_config
.version
>> 28),
426 0x0f & (target_config
.version
>> 24) );
429 /* Leave the target running...
430 * The above message stopped the target in the dbg core (MiniMon),
431 * so restart the target out of MiniMon,
433 out_msg_buf
->go_msg
.code
= GO
;
434 out_msg_buf
->go_msg
.length
= 0;
435 msg_send_serial(out_msg_buf
);
436 /* No message to expect after a GO */
441 /**************************************************************** REMOTE_CLOSE
442 ** Close the open connection to the minimon debugger.
443 Use this when you want to detach and do something else
446 mm_close (quitting
) /*FIXME: how is quitting used */
449 DENTER("mm_close()");
452 error ("Can't close remote connection: not debugging remotely.");
454 /* We should never get here if there isn't something valid in
455 mm_desc and mm_stream.
457 Due to a bug in Unix, fclose closes not only the stdio stream,
458 but also the file descriptor. So we don't actually close
462 /* close (mm_desc); */
464 /* Do not try to close mm_desc again, later in the program. */
468 #if defined (LOG_FILE)
469 if (ferror (log_file
))
470 printf ("Error writing log file.\n");
471 if (fclose (log_file
) != 0)
472 printf ("Error closing log file.\n");
475 printf ("Ending remote debugging\n");
481 /************************************************************* REMOTE_ATACH */
482 /* Attach to a program that is already loaded and running
483 * Upon exiting the process's execution is stopped.
486 mm_attach (args
, from_tty
)
491 DENTER("mm_attach()");
494 printf ("MiniMon not opened yet, use the 'target minimon' command.\n");
499 printf ("Attaching to remote program %s...\n", prog_name
);
502 /* Make sure the target is currently running, it is supposed to be. */
503 /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
504 * the dbg core. If so, we don't need to send this GO.
506 out_msg_buf
->go_msg
.code
= GO
;
507 out_msg_buf
->go_msg
.length
= 0;
508 msg_send_serial(out_msg_buf
);
509 sleep(2); /* At the worst it will stop, receive a message, continue */
511 /* Send the mm a break. */
512 out_msg_buf
->break_msg
.code
= BREAK
;
513 out_msg_buf
->break_msg
.length
= 0;
514 msg_send_serial(out_msg_buf
);
516 mark_breakpoints_out ();
517 init_wait_for_inferior ();
518 clear_proceed_status ();
519 stop_soon_quietly
= 1;
520 wait_for_inferior ();
521 stop_soon_quietly
= 0;
524 DEXIT("mm_attach()");
526 /********************************************************** REMOTE_DETACH */
527 /* Terminate the open connection to the remote debugger.
528 Use this when you want to detach and do something else
529 with your gdb. Leave remote process running (with no breakpoints set). */
531 mm_detach (args
,from_tty
)
535 DENTER("mm_dettach()");
536 remove_breakpoints(); /* Just in case there were any left in */
537 out_msg_buf
->go_msg
.code
= GO
;
538 out_msg_buf
->go_msg
.length
= 0;
539 msg_send_serial(out_msg_buf
);
540 pop_target(); /* calls mm_close to do the real work */
541 DEXIT("mm_dettach()");
545 /*************************************************************** REMOTE_RESUME
546 ** Tell the remote machine to resume. */
549 mm_resume (step
, sig
)
552 DENTER("mm_resume()");
555 error ("Can't send signals to a remote MiniMon system.");
558 out_msg_buf
->step_msg
.code
= STEP
;
559 out_msg_buf
->step_msg
.length
= 1*4;
560 out_msg_buf
->step_msg
.count
= 1; /* step 1 instruction */
561 msg_send_serial(out_msg_buf
);
563 out_msg_buf
->go_msg
.code
= GO
;
564 out_msg_buf
->go_msg
.length
= 0;
565 msg_send_serial(out_msg_buf
);
568 DEXIT("mm_resume()");
571 /***************************************************************** REMOTE_WAIT
572 ** Wait until the remote machine stops, then return,
573 storing status in STATUS just as `wait' would. */
580 int old_timeout
= timeout
;
581 int old_immediate_quit
= immediate_quit
;
584 WSETEXIT ((*status
), 0);
587 /* wait for message to arrive. It should be:
588 - A HIF service request.
589 - A HIF exit service request.
591 - A CHANNEL1 request.
592 - a debugcore HALT message.
593 HIF services must be responded too, and while-looping continued.
594 If the target stops executing, mm_wait() should return.
596 timeout
= 0; /* Wait indefinetly for a message */
597 immediate_quit
= 1; /* Helps ability to QUIT */
600 while(msg_recv_serial(in_msg_buf
)) {
601 QUIT
; /* Let user quit if they want */
603 switch (in_msg_buf
->halt_msg
.code
)
606 i
= in_msg_buf
->hif_call_rtn_msg
.service_number
;
607 result
=service_HIF(in_msg_buf
);
608 if(i
== 1) /* EXIT */
611 printf("Warning: failure during HIF service %d\n", i
);
614 service_HIF(in_msg_buf
);
617 i
=in_msg_buf
->channel1_msg
.length
;
618 in_msg_buf
->channel1_msg
.data
[i
] = '\0';
619 printf("%s", in_msg_buf
->channel1_msg
.data
);
621 /* Send CHANNEL1_ACK message */
622 out_msg_buf
->channel1_ack_msg
.code
= CHANNEL1_ACK
;
623 out_msg_buf
->channel1_ack_msg
.length
= 0;
624 result
= msg_send_serial(out_msg_buf
);
633 /* FIXME, these printfs should not be here. This is a source level
635 if (in_msg_buf
->halt_msg
.trap_number
== 0)
636 { printf("Am290*0 received vector number %d (break point)\n",
637 in_msg_buf
->halt_msg
.trap_number
);
638 WSETSTOP ((*status
), SIGTRAP
);
640 else if (in_msg_buf
->halt_msg
.trap_number
== 1)
641 { printf("Am290*0 received vector number %d\n",
642 in_msg_buf
->halt_msg
.trap_number
);
643 WSETSTOP ((*status
), SIGBUS
);
645 else if (in_msg_buf
->halt_msg
.trap_number
== 3
646 || in_msg_buf
->halt_msg
.trap_number
== 4)
647 { printf("Am290*0 received vector number %d\n",
648 in_msg_buf
->halt_msg
.trap_number
);
649 WSETSTOP ((*status
), SIGFPE
);
651 else if (in_msg_buf
->halt_msg
.trap_number
== 5)
652 { printf("Am290*0 received vector number %d\n",
653 in_msg_buf
->halt_msg
.trap_number
);
654 WSETSTOP ((*status
), SIGILL
);
656 else if (in_msg_buf
->halt_msg
.trap_number
>= 6
657 && in_msg_buf
->halt_msg
.trap_number
<= 11)
658 { printf("Am290*0 received vector number %d\n",
659 in_msg_buf
->halt_msg
.trap_number
);
660 WSETSTOP ((*status
), SIGSEGV
);
662 else if (in_msg_buf
->halt_msg
.trap_number
== 12
663 || in_msg_buf
->halt_msg
.trap_number
== 13)
664 { printf("Am290*0 received vector number %d\n",
665 in_msg_buf
->halt_msg
.trap_number
);
666 WSETSTOP ((*status
), SIGILL
);
668 else if (in_msg_buf
->halt_msg
.trap_number
== 14)
669 { printf("Am290*0 received vector number %d\n",
670 in_msg_buf
->halt_msg
.trap_number
);
671 WSETSTOP ((*status
), SIGALRM
);
673 else if (in_msg_buf
->halt_msg
.trap_number
== 15)
674 WSETSTOP ((*status
), SIGTRAP
);
675 else if (in_msg_buf
->halt_msg
.trap_number
>= 16
676 && in_msg_buf
->halt_msg
.trap_number
<= 21)
677 { printf("Am290*0 received vector number %d\n",
678 in_msg_buf
->halt_msg
.trap_number
);
679 WSETSTOP ((*status
), SIGINT
);
681 else if (in_msg_buf
->halt_msg
.trap_number
== 22)
682 { printf("Am290*0 received vector number %d\n",
683 in_msg_buf
->halt_msg
.trap_number
);
684 WSETSTOP ((*status
), SIGILL
);
685 } /* BREAK message was sent */
686 else if (in_msg_buf
->halt_msg
.trap_number
== 75)
687 WSETSTOP ((*status
), SIGTRAP
);
690 WSETEXIT ((*status
), 0);
692 timeout
= old_timeout
; /* Restore original timeout value */
693 immediate_quit
= old_immediate_quit
;
698 /******************************************************* REMOTE_FETCH_REGISTERS
699 * Read a remote register 'regno'.
700 * If regno==-1 then read all the registers.
703 mm_fetch_registers (regno
)
709 fetch_register(regno
);
713 DENTER("mm_fetch_registers()");
716 out_msg_buf
->read_req_msg
.byte_count
= 4*1;
717 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
718 out_msg_buf
->read_req_msg
.address
= 1;
719 msg_send_serial(out_msg_buf
);
720 expect_msg(READ_ACK
,in_msg_buf
,1);
721 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
722 supply_register (GR1_REGNUM
, data_p
);
724 #if defined(GR64_REGNUM) /* Read gr64-127 */
725 /* Global Registers gr64-gr95 */
726 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
727 out_msg_buf
->read_req_msg
.length
= 4*3;
728 out_msg_buf
->read_req_msg
.byte_count
= 4*32;
729 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
730 out_msg_buf
->read_req_msg
.address
= 64;
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]);
735 for (regno
=GR64_REGNUM
; regno
<GR64_REGNUM
+32; regno
++) {
736 supply_register (regno
, data_p
++);
738 #endif /* GR64_REGNUM */
740 /* Global Registers gr96-gr127 */
741 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
742 out_msg_buf
->read_req_msg
.length
= 4*3;
743 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
744 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
745 out_msg_buf
->read_req_msg
.address
= 96;
746 msg_send_serial(out_msg_buf
);
747 expect_msg(READ_ACK
,in_msg_buf
,1);
748 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
750 for (regno
=GR96_REGNUM
; regno
<GR96_REGNUM
+32; regno
++) {
751 supply_register (regno
, data_p
++);
754 /* Local Registers */
755 out_msg_buf
->read_req_msg
.byte_count
= 4 * (128);
756 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
757 out_msg_buf
->read_req_msg
.address
= 0;
758 msg_send_serial(out_msg_buf
);
759 expect_msg(READ_ACK
,in_msg_buf
,1);
760 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
762 for (regno
=LR0_REGNUM
; regno
<LR0_REGNUM
+128; regno
++) {
763 supply_register (regno
, data_p
++);
766 /* Protected Special Registers */
767 out_msg_buf
->read_req_msg
.byte_count
= 4*15;
768 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
769 out_msg_buf
->read_req_msg
.address
= 0;
770 msg_send_serial( out_msg_buf
);
771 expect_msg(READ_ACK
,in_msg_buf
,1);
772 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
774 for (regno
=0; regno
<=14; regno
++) {
775 supply_register (SR_REGNUM(regno
), data_p
++);
777 if (USE_SHADOW_PC
) { /* Let regno_to_srnum() handle the register number */
778 fetch_register(NPC_REGNUM
);
779 fetch_register(PC_REGNUM
);
780 fetch_register(PC2_REGNUM
);
783 /* Unprotected Special Registers */
784 out_msg_buf
->read_req_msg
.byte_count
= 4*8;
785 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
786 out_msg_buf
->read_req_msg
.address
= 128;
787 msg_send_serial( out_msg_buf
);
788 expect_msg(READ_ACK
,in_msg_buf
,1);
789 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
791 for (regno
=128; regno
<=135; regno
++) {
792 supply_register (SR_REGNUM(regno
), data_p
++);
795 /* There doesn't seem to be any way to get these. */
798 supply_register (FPE_REGNUM
, &val
);
799 supply_register (INT_REGNUM
, &val
);
800 supply_register (FPS_REGNUM
, &val
);
801 supply_register (EXO_REGNUM
, &val
);
804 DEXIT("mm_fetch_registerS()");
808 /****************************************************** REMOTE_STORE_REGISTERS
809 ** Store register regno into the target.
810 * If regno==-1 then store all the registers.
814 mm_store_registers (regno
)
819 return(store_register(regno
));
821 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 expect_msg(WRITE_ACK
,in_msg_buf
,1);
835 #if defined(GR64_REGNUM)
836 /* Global registers gr64-gr95 */
837 out_msg_buf
->write_r_msg
.byte_count
= 4* (32);
838 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
839 out_msg_buf
->write_r_msg
.address
= 64;
841 for (regno
=GR64_REGNUM
; regno
<GR64_REGNUM
+32 ; regno
++)
843 out_msg_buf
->write_r_msg
.data
[regno
-GR64_REGNUM
] = read_register (regno
);
845 msg_send_serial(out_msg_buf
);
846 expect_msg(WRITE_ACK
,in_msg_buf
,1);
847 #endif /* GR64_REGNUM */
849 /* Global registers gr96-gr127 */
850 out_msg_buf
->write_r_msg
.byte_count
= 4* (32);
851 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
852 out_msg_buf
->write_r_msg
.address
= 96;
853 for (regno
=GR96_REGNUM
; regno
<GR96_REGNUM
+32 ; regno
++)
855 out_msg_buf
->write_r_msg
.data
[regno
-GR96_REGNUM
] = read_register (regno
);
857 msg_send_serial( out_msg_buf
);
858 expect_msg(WRITE_ACK
,in_msg_buf
,1);
860 /* Local Registers */
861 out_msg_buf
->write_r_msg
.memory_space
= LOCAL_REG
;
862 out_msg_buf
->write_r_msg
.byte_count
= 4*128;
863 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
864 out_msg_buf
->write_r_msg
.address
= 0;
866 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+128 ; regno
++)
868 out_msg_buf
->write_r_msg
.data
[regno
-LR0_REGNUM
] = read_register (regno
);
870 msg_send_serial( out_msg_buf
);
871 expect_msg(WRITE_ACK
,in_msg_buf
,1);
873 /* Protected Special Registers */
874 /* VAB through TMR */
875 out_msg_buf
->write_r_msg
.memory_space
= SPECIAL_REG
;
876 out_msg_buf
->write_r_msg
.byte_count
= 4* 10;
877 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
878 out_msg_buf
->write_r_msg
.address
= 0;
879 for (regno
= 0 ; regno
<=9 ; regno
++) /* VAB through TMR */
880 out_msg_buf
->write_r_msg
.data
[regno
] = read_register (SR_REGNUM(regno
));
881 msg_send_serial( out_msg_buf
);
882 expect_msg(WRITE_ACK
,in_msg_buf
,1);
884 /* PC0, PC1, PC2 possibly as shadow registers */
885 out_msg_buf
->write_r_msg
.byte_count
= 4* 3;
886 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
887 for (regno
=10 ; regno
<=12 ; regno
++) /* LRU and MMU */
888 out_msg_buf
->write_r_msg
.data
[regno
-10] = read_register (SR_REGNUM(regno
));
890 out_msg_buf
->write_r_msg
.address
= 20; /* SPC0 */
892 out_msg_buf
->write_r_msg
.address
= 10; /* PC0 */
893 msg_send_serial( out_msg_buf
);
894 expect_msg(WRITE_ACK
,in_msg_buf
,1);
897 out_msg_buf
->write_r_msg
.byte_count
= 4* 2;
898 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
899 out_msg_buf
->write_r_msg
.address
= 13;
900 for (regno
=13 ; regno
<=14 ; regno
++) /* LRU and MMU */
901 out_msg_buf
->write_r_msg
.data
[regno
-13] = read_register (SR_REGNUM(regno
));
902 msg_send_serial( out_msg_buf
);
903 expect_msg(WRITE_ACK
,in_msg_buf
,1);
905 /* Unprotected Special Registers */
906 out_msg_buf
->write_r_msg
.byte_count
= 4*8;
907 out_msg_buf
->write_r_msg
.length
= 3*4 + out_msg_buf
->write_r_msg
.byte_count
;
908 out_msg_buf
->write_r_msg
.address
= 128;
909 for (regno
= 128 ; regno
<=135 ; regno
++)
910 out_msg_buf
->write_r_msg
.data
[regno
-128] = read_register(SR_REGNUM(regno
));
911 msg_send_serial( out_msg_buf
);
912 expect_msg(WRITE_ACK
,in_msg_buf
,1);
914 registers_changed ();
915 DEXIT("mm_store_registers()");
918 /*************************************************** REMOTE_PREPARE_TO_STORE */
919 /* Get ready to modify the registers array. On machines which store
920 individual registers, this doesn't need to do anything. On machines
921 which store all the registers in one fell swoop, this makes sure
922 that registers contains all the registers from the program being
926 mm_prepare_to_store ()
928 /* Do nothing, since we can store individual regs */
931 /******************************************************* REMOTE_XFER_MEMORY */
936 #if defined(KERNEL_DEBUGGING)
937 /* Check for a virtual address in the kernel */
938 /* Assume physical address of ublock is in paddr_u register */
939 /* FIXME: doesn't work for user virtual addresses */
940 if (addr
>= UVADDR
) {
941 /* PADDR_U register holds the physical address of the ublock */
942 CORE_ADDR i
= (CORE_ADDR
)read_register(PADDR_U_REGNUM
);
943 return(i
+ addr
- (CORE_ADDR
)UVADDR
);
951 /* FIXME! Merge these two. */
953 mm_xfer_inferior_memory (memaddr
, myaddr
, len
, write
)
960 memaddr
= translate_addr(memaddr
);
963 return mm_write_inferior_memory (memaddr
, myaddr
, len
);
965 return mm_read_inferior_memory (memaddr
, myaddr
, len
);
968 /******************************************************* REMOTE_FILES_INFO */
972 printf ("\tAttached to %s at %d baud and running program %s.\n",
973 dev_name
, baudrate
, prog_name
);
976 /************************************************* REMOTE_INSERT_BREAKPOINT */
978 mm_insert_breakpoint (addr
, contents_cache
)
980 char *contents_cache
;
982 DENTER("mm_insert_breakpoint()");
983 out_msg_buf
->bkpt_set_msg
.code
= BKPT_SET
;
984 out_msg_buf
->bkpt_set_msg
.length
= 4*4;
985 out_msg_buf
->bkpt_set_msg
.memory_space
= I_MEM
;
986 out_msg_buf
->bkpt_set_msg
.bkpt_addr
= (ADDR32
) addr
;
987 out_msg_buf
->bkpt_set_msg
.pass_count
= 1;
988 out_msg_buf
->bkpt_set_msg
.bkpt_type
= -1; /* use illop for 29000 */
989 msg_send_serial( out_msg_buf
);
990 if (expect_msg(BKPT_SET_ACK
,in_msg_buf
,1)) {
991 DEXIT("mm_insert_breakpoint() success");
992 return 0; /* Success */
994 DEXIT("mm_insert_breakpoint() failure");
995 return 1; /* Failure */
999 /************************************************* REMOTE_DELETE_BREAKPOINT */
1001 mm_remove_breakpoint (addr
, contents_cache
)
1003 char *contents_cache
;
1005 DENTER("mm_remove_breakpoint()");
1006 out_msg_buf
->bkpt_rm_msg
.code
= BKPT_RM
;
1007 out_msg_buf
->bkpt_rm_msg
.length
= 4*3;
1008 out_msg_buf
->bkpt_rm_msg
.memory_space
= I_MEM
;
1009 out_msg_buf
->bkpt_rm_msg
.bkpt_addr
= (ADDR32
) addr
;
1010 msg_send_serial( out_msg_buf
);
1011 if (expect_msg(BKPT_RM_ACK
,in_msg_buf
,1)) {
1012 DEXIT("mm_remove_breakpoint()");
1013 return 0; /* Success */
1015 DEXIT("mm_remove_breakpoint()");
1016 return 1; /* Failure */
1021 /******************************************************* REMOTE_KILL */
1023 mm_kill(arg
,from_tty
)
1029 DENTER("mm_kill()");
1030 #if defined(KERNEL_DEBUGGING)
1031 /* We don't ever kill the kernel */
1033 printf("Kernel not killed, but left in current state.\n");
1034 printf("Use detach to leave kernel running.\n");
1037 out_msg_buf
->break_msg
.code
= BREAK
;
1038 out_msg_buf
->bkpt_set_msg
.length
= 4*0;
1039 expect_msg(HALT
,in_msg_buf
,from_tty
);
1041 printf("Target has been stopped.");
1042 printf("Would you like to do a hardware reset (y/n) [n] ");
1044 if (buf
[0] == 'y') {
1045 out_msg_buf
->reset_msg
.code
= RESET
;
1046 out_msg_buf
->bkpt_set_msg
.length
= 4*0;
1047 expect_msg(RESET_ACK
,in_msg_buf
,from_tty
);
1048 printf("Target has been reset.");
1058 /***************************************************************************/
1060 * Load a program into the target.
1063 mm_load(arg_string
,from_tty
)
1069 #if defined(KERNEL_DEBUGGING)
1070 printf("The kernel had better be loaded already! Loading not done.\n");
1072 if (arg_string
== 0)
1073 error ("The load command takes a file name");
1075 arg_string
= tilde_expand (arg_string
);
1076 make_cleanup (free
, arg_string
);
1079 error("File loading is not yet supported for MiniMon.");
1080 /* FIXME, code to load your file here... */
1081 /* You may need to do an init_target_mm() */
1082 /* init_target_mm(?,?,?,?,?,?,?,?); */
1084 symbol_file_add (arg_string
, from_tty
, text_addr
, 0);
1089 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1090 ** Copy LEN bytes of data from debugger memory at MYADDR
1091 to inferior's memory at MEMADDR. Returns number of bytes written. */
1093 mm_write_inferior_memory (memaddr
, myaddr
, len
)
1100 /* DENTER("mm_write_inferior_memory()"); */
1101 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1102 out_msg_buf
->write_req_msg
.memory_space
= mm_memory_space(memaddr
);
1105 while (nwritten
< len
) {
1106 int num_to_write
= len
- nwritten
;
1107 if (num_to_write
> MAXDATA
) num_to_write
= MAXDATA
;
1108 for (i
=0 ; i
< num_to_write
; i
++)
1109 out_msg_buf
->write_req_msg
.data
[i
] = myaddr
[i
+nwritten
];
1110 out_msg_buf
->write_req_msg
.byte_count
= num_to_write
;
1111 out_msg_buf
->write_req_msg
.length
= 3*4 + num_to_write
;
1112 out_msg_buf
->write_req_msg
.address
= memaddr
+ nwritten
;
1113 msg_send_serial(out_msg_buf
);
1115 if (expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
1116 nwritten
+= in_msg_buf
->write_ack_msg
.byte_count
;
1121 /* DEXIT("mm_write_inferior_memory()"); */
1125 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1126 ** Read LEN bytes from inferior memory at MEMADDR. Put the result
1127 at debugger address MYADDR. Returns number of bytes read. */
1129 mm_read_inferior_memory(memaddr
, myaddr
, len
)
1136 /* DENTER("mm_read_inferior_memory()"); */
1137 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1138 out_msg_buf
->read_req_msg
.memory_space
= mm_memory_space(memaddr
);
1141 while (nread
< len
) {
1142 int num_to_read
= (len
- nread
);
1143 if (num_to_read
> MAXDATA
) num_to_read
= MAXDATA
;
1144 out_msg_buf
->read_req_msg
.byte_count
= num_to_read
;
1145 out_msg_buf
->read_req_msg
.length
= 3*4 + num_to_read
;
1146 out_msg_buf
->read_req_msg
.address
= memaddr
+ nread
;
1147 msg_send_serial(out_msg_buf
);
1149 if (expect_msg(READ_ACK
,in_msg_buf
,1)) {
1150 for (i
=0 ; i
<in_msg_buf
->read_ack_msg
.byte_count
; i
++)
1151 myaddr
[i
+nread
] = in_msg_buf
->read_ack_msg
.data
[i
];
1152 nread
+= in_msg_buf
->read_ack_msg
.byte_count
;
1160 /********************************************************** MSG_SEND_SERIAL
1161 ** This function is used to send a message over the
1164 ** If the message is successfully sent, a zero is
1165 ** returned. If the message was not sendable, a -1
1166 ** is returned. This function blocks. That is, it
1167 ** does not return until the message is completely
1168 ** sent, or until an error is encountered.
1173 msg_send_serial(msg_ptr
)
1174 union msg_t
*msg_ptr
;
1181 /* Send message header */
1183 message_size
= msg_ptr
->generic_msg
.length
+ (2 * sizeof(INT32
));
1185 c
= *((char *)msg_ptr
+byte_count
);
1186 result
= write(mm_desc
, &c
, 1);
1188 byte_count
= byte_count
+ 1;
1190 } while ((byte_count
< message_size
) );
1193 } /* end msg_send_serial() */
1195 /********************************************************** MSG_RECV_SERIAL
1196 ** This function is used to receive a message over a
1199 ** If the message is waiting in the buffer, a zero is
1200 ** returned and the buffer pointed to by msg_ptr is filled
1201 ** in. If no message was available, a -1 is returned.
1202 ** If timeout==0, wait indefinetly for a character.
1207 msg_recv_serial(msg_ptr
)
1208 union msg_t
*msg_ptr
;
1210 static INT32 length
=0;
1211 static INT32 byte_count
=0;
1214 if(msg_ptr
== 0) /* re-sync request */
1218 /* The timeout here is the prevailing timeout set with VTIME */
1219 ->"timeout==0 semantics not supported"
1220 read(mm_desc
, in_buf
, BUFER_SIZE
);
1223 read(mm_desc
, in_buf
, BUFER_SIZE
);
1228 /* Receive message */
1230 /* Timeout==0, help support the mm_wait() routine */
1231 ->"timeout==0 semantics not supported (and its nice if they are)"
1232 result
= read(mm_desc
, &c
, 1);
1235 result
= read(mm_desc
, &c
, 1);
1239 if (errno
== EINTR
) {
1240 error ("Timeout reading from remote system.");
1242 perror_with_name ("remote");
1243 } else if (result
== 1) {
1244 *((char *)msg_ptr
+byte_count
) = c
;
1245 byte_count
= byte_count
+ 1;
1248 /* Message header received. Save message length. */
1249 if (byte_count
== (2 * sizeof(INT32
)))
1250 length
= msg_ptr
->generic_msg
.length
;
1252 if (byte_count
>= (length
+ (2 * sizeof(INT32
)))) {
1253 /* Message received */
1259 } /* end msg_recv_serial() */
1261 /********************************************************************* KBD_RAW
1262 ** This function is used to put the keyboard in "raw"
1263 ** mode for BSD Unix. The original status is saved
1264 ** so that it may be restored later.
1273 /* Get keyboard termio (to save to restore original modes) */
1275 result
= ioctl(0, TCGETA
, &kbd_tbuf
);
1277 result
= ioctl(0, TIOCGETP
, &kbd_tbuf
);
1282 /* Get keyboard TERMINAL (for modification) */
1284 result
= ioctl(0, TCGETA
, &tbuf
);
1286 result
= ioctl(0, TIOCGETP
, &tbuf
);
1291 /* Set up new parameters */
1293 tbuf
.c_iflag
= tbuf
.c_iflag
&
1294 ~(INLCR
| ICRNL
| IUCLC
| ISTRIP
| IXON
| BRKINT
);
1295 tbuf
.c_lflag
= tbuf
.c_lflag
& ~(ICANON
| ISIG
| ECHO
);
1296 tbuf
.c_cc
[4] = 0; /* MIN */
1297 tbuf
.c_cc
[5] = 0; /* TIME */
1299 /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1300 tbuf
.sg_flags
|= RAW
;
1301 tbuf
.sg_flags
|= ANYP
;
1302 tbuf
.sg_flags
&= ~ECHO
;
1305 /* Set keyboard termio to new mode (RAW) */
1307 result
= ioctl(0, TCSETAF
, &tbuf
);
1309 result
= ioctl(0, TIOCSETP
, &tbuf
);
1315 } /* end kbd_raw() */
1319 /***************************************************************** KBD_RESTORE
1320 ** This function is used to put the keyboard back in the
1321 ** mode it was in before kbk_raw was called. Note that
1322 ** kbk_raw() must have been called at least once before
1323 ** kbd_restore() is called.
1330 /* Set keyboard termio to original mode */
1332 result
= ioctl(0, TCSETAF
, &kbd_tbuf
);
1334 result
= ioctl(0, TIOCGETP
, &kbd_tbuf
);
1341 } /* end kbd_cooked() */
1344 /*****************************************************************************/
1345 /* Fetch a single register indicatated by 'regno'.
1346 * Returns 0/-1 on success/failure.
1349 fetch_register (regno
)
1353 DENTER("mm_fetch_register()");
1354 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1355 out_msg_buf
->read_req_msg
.length
= 4*3;
1356 out_msg_buf
->read_req_msg
.byte_count
= 4;
1358 if (regno
== GR1_REGNUM
)
1359 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1360 out_msg_buf
->read_req_msg
.address
= 1;
1362 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1363 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1364 out_msg_buf
->read_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1366 #if defined(GR64_REGNUM)
1367 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32 )
1368 { out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1369 out_msg_buf
->read_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1371 #endif /* GR64_REGNUM */
1372 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1373 { out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
1374 out_msg_buf
->read_req_msg
.address
= (regno
- LR0_REGNUM
);
1376 else if (regno
>=FPE_REGNUM
&& regno
<=EXO_REGNUM
)
1378 supply_register(160 + (regno
- FPE_REGNUM
),&val
);
1379 return 0; /* Pretend Success */
1382 { out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
1383 out_msg_buf
->read_req_msg
.address
= regnum_to_srnum(regno
);
1386 msg_send_serial(out_msg_buf
);
1388 if (expect_msg(READ_ACK
,in_msg_buf
,1)) {
1389 supply_register (regno
, &(in_msg_buf
->read_r_ack_msg
.data
[0]));
1394 DEXIT("mm_fetch_register()");
1397 /*****************************************************************************/
1398 /* Store a single register indicated by 'regno'.
1399 * Returns 0/-1 on success/failure.
1402 store_register (regno
)
1407 DENTER("store_register()");
1408 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1409 out_msg_buf
->write_req_msg
.length
= 4*4;
1410 out_msg_buf
->write_req_msg
.byte_count
= 4;
1411 out_msg_buf
->write_r_msg
.data
[0] = read_register (regno
);
1413 if (regno
== GR1_REGNUM
)
1414 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1415 out_msg_buf
->write_req_msg
.address
= 1;
1416 /* Setting GR1 changes the numbers of all the locals, so invalidate the
1417 * register cache. Do this *after* calling read_register, because we want
1418 * read_register to return the value that write_register has just stuffed
1419 * into the registers array, not the value of the register fetched from
1422 registers_changed ();
1424 #if defined(GR64_REGNUM)
1425 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32 )
1426 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1427 out_msg_buf
->write_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1429 #endif /* GR64_REGNUM */
1430 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1431 { out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1432 out_msg_buf
->write_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1434 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1435 { out_msg_buf
->write_req_msg
.memory_space
= LOCAL_REG
;
1436 out_msg_buf
->write_req_msg
.address
= (regno
- LR0_REGNUM
);
1438 else if (regno
>=FPE_REGNUM
&& regno
<=EXO_REGNUM
)
1440 return 0; /* Pretend Success */
1442 else /* An unprotected or protected special register */
1443 { out_msg_buf
->write_req_msg
.memory_space
= SPECIAL_REG
;
1444 out_msg_buf
->write_req_msg
.address
= regnum_to_srnum(regno
);
1447 msg_send_serial(out_msg_buf
);
1449 if (expect_msg(WRITE_ACK
,in_msg_buf
,1)) {
1454 DEXIT("store_register()");
1457 /****************************************************************************/
1459 * Convert a gdb special register number to a 29000 special register number.
1462 regnum_to_srnum(regno
)
1466 case VAB_REGNUM
: return(0);
1467 case OPS_REGNUM
: return(1);
1468 case CPS_REGNUM
: return(2);
1469 case CFG_REGNUM
: return(3);
1470 case CHA_REGNUM
: return(4);
1471 case CHD_REGNUM
: return(5);
1472 case CHC_REGNUM
: return(6);
1473 case RBP_REGNUM
: return(7);
1474 case TMC_REGNUM
: return(8);
1475 case TMR_REGNUM
: return(9);
1476 case NPC_REGNUM
: return(USE_SHADOW_PC
? (20) : (10));
1477 case PC_REGNUM
: return(USE_SHADOW_PC
? (21) : (11));
1478 case PC2_REGNUM
: return(USE_SHADOW_PC
? (22) : (12));
1479 case MMU_REGNUM
: return(13);
1480 case LRU_REGNUM
: return(14);
1481 case IPC_REGNUM
: return(128);
1482 case IPA_REGNUM
: return(129);
1483 case IPB_REGNUM
: return(130);
1484 case Q_REGNUM
: return(131);
1485 case ALU_REGNUM
: return(132);
1486 case BP_REGNUM
: return(133);
1487 case FC_REGNUM
: return(134);
1488 case CR_REGNUM
: return(135);
1489 case FPE_REGNUM
: return(160);
1490 case INT_REGNUM
: return(161);
1491 case FPS_REGNUM
: return(162);
1492 case EXO_REGNUM
:return(164);
1494 return(255); /* Failure ? */
1497 /****************************************************************************/
1499 * Initialize the target debugger (minimon only).
1502 init_target_mm(tstart
,tend
,dstart
,dend
,entry
,ms_size
,rs_size
,arg_start
)
1503 ADDR32 tstart
,tend
,dstart
,dend
,entry
;
1504 INT32 ms_size
,rs_size
;
1507 out_msg_buf
->init_msg
.code
= INIT
;
1508 out_msg_buf
->init_msg
.length
= sizeof(struct init_msg_t
)-2*sizeof(INT32
);
1509 out_msg_buf
->init_msg
.text_start
= tstart
;
1510 out_msg_buf
->init_msg
.text_end
= tend
;
1511 out_msg_buf
->init_msg
.data_start
= dstart
;
1512 out_msg_buf
->init_msg
.data_end
= dend
;
1513 out_msg_buf
->init_msg
.entry_point
= entry
;
1514 out_msg_buf
->init_msg
.mem_stack_size
= ms_size
;
1515 out_msg_buf
->init_msg
.reg_stack_size
= rs_size
;
1516 out_msg_buf
->init_msg
.arg_start
= arg_start
;
1517 msg_send_serial(out_msg_buf
);
1518 expect_msg(INIT_ACK
,in_msg_buf
,1);
1520 /****************************************************************************/
1522 * Return a pointer to a string representing the given message code.
1523 * Not all messages are represented here, only the ones that we expect
1524 * to be called with.
1530 static char cbuf
[32];
1533 case BKPT_SET_ACK
: sprintf(cbuf
,"%s (%d)","BKPT_SET_ACK",code
); break;
1534 case BKPT_RM_ACK
: sprintf(cbuf
,"%s (%d)","BKPT_RM_ACK",code
); break;
1535 case INIT_ACK
: sprintf(cbuf
,"%s (%d)","INIT_ACK",code
); break;
1536 case READ_ACK
: sprintf(cbuf
,"%s (%d)","READ_ACK",code
); break;
1537 case WRITE_ACK
: sprintf(cbuf
,"%s (%d)","WRITE_ACK",code
); break;
1538 case ERROR
: sprintf(cbuf
,"%s (%d)","ERROR",code
); break;
1539 case HALT
: sprintf(cbuf
,"%s (%d)","HALT",code
); break;
1540 default: sprintf(cbuf
,"UNKNOWN (%d)",code
); break;
1544 /****************************************************************************/
1546 * Selected (not all of them) error codes that we might get.
1552 static char cbuf
[50];
1555 case EMFAIL
: return("EMFAIL: unrecoverable error");
1556 case EMBADADDR
: return("EMBADADDR: Illegal address");
1557 case EMBADREG
: return("EMBADREG: Illegal register ");
1558 case EMACCESS
: return("EMACCESS: Could not access memory");
1559 case EMBADMSG
: return("EMBADMSG: Unknown message type");
1560 case EMMSG2BIG
: return("EMMSG2BIG: Message to large");
1561 case EMNOSEND
: return("EMNOSEND: Could not send message");
1562 case EMNORECV
: return("EMNORECV: Could not recv message");
1563 case EMRESET
: return("EMRESET: Could not RESET target");
1564 case EMCONFIG
: return("EMCONFIG: Could not get target CONFIG");
1565 case EMSTATUS
: return("EMSTATUS: Could not get target STATUS");
1566 case EMREAD
: return("EMREAD: Could not READ target memory");
1567 case EMWRITE
: return("EMWRITE: Could not WRITE target memory");
1568 case EMBKPTSET
: return("EMBKPTSET: Could not set breakpoint");
1569 case EMBKPTRM
: return("EMBKPTRM: Could not remove breakpoint");
1570 case EMBKPTSTAT
:return("EMBKPTSTAT: Could not get breakpoint status");
1571 case EMBKPTNONE
:return("EMBKPTNONE: All breakpoints in use");
1572 case EMBKPTUSED
:return("EMBKPTUSED: Breakpoints already in use");
1573 case EMINIT
: return("EMINIT: Could not init target memory");
1574 case EMGO
: return("EMGO: Could not start execution");
1575 case EMSTEP
: return("EMSTEP: Could not single step");
1576 case EMBREAK
: return("EMBREAK: Could not BREAK");
1577 case EMCOMMERR
: return("EMCOMMERR: Communication error");
1578 default: sprintf(cbuf
,"error number %d",code
); break;
1583 /****************************************************************************/
1585 * Receive a message and expect it to be of type msgcode.
1586 * Returns 0/1 on failure/success.
1589 expect_msg(msgcode
,msg_buf
,from_tty
)
1590 INT32 msgcode
; /* Msg code we expect */
1591 union msg_t
*msg_buf
; /* Where to put the message received */
1592 int from_tty
; /* Print message on error if non-zero */
1594 /* DENTER("expect_msg()"); */
1596 while(msg_recv_serial(msg_buf
) && (retries
++<MAX_RETRIES
));
1597 if (retries
>= MAX_RETRIES
) {
1598 printf("Expected msg %s, ",msg_str(msgcode
));
1599 printf("no message received!\n");
1600 /* DEXIT("expect_msg() failure"); */
1601 return(0); /* Failure */
1604 if (msg_buf
->generic_msg
.code
!= msgcode
) {
1606 printf("Expected msg %s, ",msg_str(msgcode
));
1607 printf("got msg %s\n",msg_str(msg_buf
->generic_msg
.code
));
1608 if (msg_buf
->generic_msg
.code
== ERROR
)
1609 printf("%s\n",error_msg_str(msg_buf
->error_msg
.error_code
));
1611 /* DEXIT("expect_msg() failure"); */
1612 return(0); /* Failure */
1614 /* DEXIT("expect_msg() success"); */
1615 return(1); /* Success */
1617 /****************************************************************************/
1619 * Determine the MiniMon memory space qualifier based on the addr.
1620 * FIXME: Can't distinguis I_ROM/D_ROM.
1621 * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1624 mm_memory_space(addr
)
1627 ADDR32 tstart
= target_config
.I_mem_start
;
1628 ADDR32 tend
= tstart
+ target_config
.I_mem_size
;
1629 ADDR32 dstart
= target_config
.D_mem_start
;
1630 ADDR32 dend
= tstart
+ target_config
.D_mem_size
;
1631 ADDR32 rstart
= target_config
.ROM_start
;
1632 ADDR32 rend
= tstart
+ target_config
.ROM_size
;
1634 if (((ADDR32
)addr
>= tstart
) && ((ADDR32
)addr
< tend
)) {
1636 } else if (((ADDR32
)addr
>= dstart
) && ((ADDR32
)addr
< dend
)) {
1638 } else if (((ADDR32
)addr
>= rstart
) && ((ADDR32
)addr
< rend
)) {
1639 /* FIXME: how do we determine between D_ROM and I_ROM */
1641 } else /* FIXME: what do me do now? */
1642 return D_MEM
; /* Hmmm! */
1645 /****************************************************************************/
1647 * Define the target subroutine names
1649 struct target_ops mm_ops
= {
1650 "minimon", "Remote AMD/Minimon target",
1651 "Remote debug an AMD 290*0 using the MiniMon dbg core on the target",
1653 mm_attach
, mm_detach
, mm_resume
, mm_wait
,
1654 mm_fetch_registers
, mm_store_registers
,
1655 mm_prepare_to_store
, 0, 0, /* conv_to, conv_from */
1656 mm_xfer_inferior_memory
,
1658 mm_insert_breakpoint
, mm_remove_breakpoint
, /* Breakpoints */
1659 0, 0, 0, 0, 0, /* Terminal handling */
1660 mm_kill
, /* FIXME, kill */
1662 call_function_by_hand
,
1663 0, /* lookup_symbol */
1664 mm_create_inferior
, /* create_inferior */
1665 mm_mourn
, /* mourn_inferior FIXME */
1666 process_stratum
, 0, /* next */
1667 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1668 0,0, /* sections, sections_end */
1669 OPS_MAGIC
, /* Always the last thing */
1673 _initialize_remote_mm()
1675 add_target (&mm_ops
);
1678 #ifdef NO_HIF_SUPPORT
1682 return(0); /* Emulate a failure */