1 /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
2 Copyright 1990, 1991, 1992, 2001 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This is like remote.c but ecpects MiniMON to be running on the Am29000
24 - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this
25 file to gdb 3.95. I was unable to get this working on sun3os4
26 with termio, only with sgtty. Because we are only attempting to
27 use this module to debug our kernel, which is already loaded when
28 gdb is started up, I did not code up the file downloading facilities.
29 As a result this module has only the stubs to download files.
30 You should get tagged at compile time if you need to make any
40 #include "gdb_string.h"
45 /* Offset of member MEMBER in a struct of type TYPE. */
46 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
48 #define DRAIN_INPUT() (msg_recv_serial((union msg_t*)0))
50 extern int stop_soon_quietly
; /* for wait_for_inferior */
52 static void mm_resume ();
53 static void mm_fetch_registers ();
54 static int fetch_register ();
55 static void mm_store_registers ();
56 static int store_register ();
57 static int regnum_to_srnum ();
58 static void mm_close ();
59 static char *msg_str ();
60 static char *error_msg_str ();
61 static int expect_msg ();
62 static void init_target_mm ();
63 static int mm_memory_space ();
65 #define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
66 #define USE_SHADOW_PC ((processor_type == a29k_freeze_mode) && FREEZE_MODE)
68 /* FIXME: Replace with `set remotedebug'. */
69 #define LLOG_FILE "minimon.log"
70 #if defined (LOG_FILE)
75 * Size of message buffers. I couldn't get memory reads to work when
76 * the byte_count was larger than 512 (it may be a baud rate problem).
78 #define BUFER_SIZE 512
80 * Size of data area in message buffer on the TARGET (remote system).
82 #define MAXDATA_T (target_config.max_msg_size - \
83 offsetof(struct write_r_msg_t,data[0]))
85 * Size of data area in message buffer on the HOST (gdb).
87 #define MAXDATA_H (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
89 * Defined as the minimum size of data areas of the two message buffers
91 #define MAXDATA (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
93 static char out_buf
[BUFER_SIZE
];
94 static char in_buf
[BUFER_SIZE
];
96 int msg_recv_serial ();
97 int msg_send_serial ();
99 #define MAX_RETRIES 5000
100 extern struct target_ops mm_ops
; /* Forward declaration */
101 struct config_msg_t target_config
; /* HIF needs this */
102 union msg_t
*out_msg_buf
= (union msg_t
*) out_buf
;
103 union msg_t
*in_msg_buf
= (union msg_t
*) in_buf
;
105 static int timeout
= 5;
107 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
108 mm_open knows that we don't have a file open when the program
112 /* stream which is fdopen'd from mm_desc. Only valid when
116 /* Called when SIGALRM signal sent due to alarm() timeout. */
125 volatile int n_alarms
;
132 printf ("mm_timer called\n");
136 #endif /* HAVE_TERMIO */
138 /* malloc'd name of the program on the remote system. */
139 static char *prog_name
= NULL
;
142 /* Number of SIGTRAPs we need to simulate. That is, the next
143 NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
144 SIGTRAP without actually waiting for anything. */
146 /**************************************************** REMOTE_CREATE_INFERIOR */
147 /* This is called not only when we first attach, but also when the
148 user types "run" after having attached. */
150 mm_create_inferior (char *execfile
, char *args
, char **env
)
152 #define MAX_TOKENS 25
153 #define BUFFER_SIZE 256
156 char *token
[MAX_TOKENS
];
157 char cmd_line
[BUFFER_SIZE
];
160 error ("Can't pass arguments to remote mm process (yet).");
162 if (execfile
== 0 /* || exec_bfd == 0 */ )
163 error ("No executable file specified");
167 printf ("Minimon not open yet.\n");
171 /* On ultra3 (NYU) we assume the kernel is already running so there is
173 FIXME: Fixed required here -> load your program, possibly with mm_load().
175 printf_filtered ("\n\
176 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
178 /* We will get a task spawn event immediately. */
179 init_wait_for_inferior ();
180 clear_proceed_status ();
181 stop_soon_quietly
= 1;
182 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
185 /**************************************************** REMOTE_MOURN_INFERIOR */
189 pop_target (); /* Pop back to no-child state */
190 generic_mourn_inferior ();
193 /********************************************************************** damn_b
195 /* Translate baud rates from integers to damn B_codes. Unix should
196 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
286 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
287 if (rate
== baudtab
[i
].rate
)
288 return baudtab
[i
].damn_b
;
289 return B38400
; /* Random */
293 /***************************************************************** REMOTE_OPEN
294 ** Open a connection to remote minimon.
295 NAME is the filename used for communication, then a space,
297 'target adapt /dev/ttya 9600 [prognam]' for example.
300 static char *dev_name
;
303 mm_open (char *name
, int from_tty
)
309 /* Find the first whitespace character, it separates dev_name from
312 p
&& *p
&& !isspace (*p
); p
++)
314 if (p
== 0 || *p
== '\0')
316 error ("Usage : <command> <serial-device> <baud-rate> [progname]");
317 dev_name
= (char *) xmalloc (p
- name
+ 1);
318 strncpy (dev_name
, name
, p
- name
);
319 dev_name
[p
- name
] = '\0';
321 /* Skip over the whitespace after dev_name */
322 for (; isspace (*p
); p
++)
325 if (1 != sscanf (p
, "%d ", &baudrate
))
328 /* Skip the number and then the spaces */
329 for (; isdigit (*p
); p
++)
331 for (; isspace (*p
); p
++)
334 if (prog_name
!= NULL
)
336 prog_name
= savestring (p
, strlen (p
));
342 mm_desc
= open (dev_name
, O_RDWR
);
344 perror_with_name (dev_name
);
345 ioctl (mm_desc
, TIOCGETP
, &sg
);
347 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
348 sg
.c_cc
[VTIME
] = timeout
* 10;
349 sg
.c_lflag
&= ~(ICANON
| ECHO
);
350 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
352 sg
.sg_ispeed
= damn_b (baudrate
);
353 sg
.sg_ospeed
= damn_b (baudrate
);
356 sg
.sg_flags
&= ~ECHO
;
360 ioctl (mm_desc
, TIOCSETP
, &sg
);
361 mm_stream
= fdopen (mm_desc
, "r+");
363 push_target (&mm_ops
);
366 #ifndef NO_SIGINTERRUPT
367 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
369 if (siginterrupt (SIGALRM
, 1) != 0)
370 perror ("mm_open: error in siginterrupt");
373 /* Set up read timeout timer. */
374 if ((void (*)) signal (SIGALRM
, mm_timer
) == (void (*)) -1)
375 perror ("mm_open: error in signal");
378 #if defined (LOG_FILE)
379 log_file
= fopen (LOG_FILE
, "w");
380 if (log_file
== NULL
)
381 perror_with_name (LOG_FILE
);
384 ** Initialize target configuration structure (global)
387 out_msg_buf
->config_req_msg
.code
= CONFIG_REQ
;
388 out_msg_buf
->config_req_msg
.length
= 4 * 0;
389 msg_send_serial (out_msg_buf
); /* send config request message */
391 expect_msg (CONFIG
, in_msg_buf
, 1);
393 a29k_get_processor_type ();
395 /* Print out some stuff, letting the user now what's going on */
396 printf_filtered ("Connected to MiniMon via %s.\n", dev_name
);
397 /* FIXME: can this restriction be removed? */
398 printf_filtered ("Remote debugging using virtual addresses works only\n");
399 printf_filtered ("\twhen virtual addresses map 1:1 to physical addresses.\n")
401 if (processor_type
!= a29k_freeze_mode
)
403 fprintf_filtered (gdb_stderr
,
404 "Freeze-mode debugging not available, and can only be done on an A29050.\n");
407 target_config
.code
= CONFIG
;
408 target_config
.length
= 0;
409 target_config
.processor_id
= in_msg_buf
->config_msg
.processor_id
;
410 target_config
.version
= in_msg_buf
->config_msg
.version
;
411 target_config
.I_mem_start
= in_msg_buf
->config_msg
.I_mem_start
;
412 target_config
.I_mem_size
= in_msg_buf
->config_msg
.I_mem_size
;
413 target_config
.D_mem_start
= in_msg_buf
->config_msg
.D_mem_start
;
414 target_config
.D_mem_size
= in_msg_buf
->config_msg
.D_mem_size
;
415 target_config
.ROM_start
= in_msg_buf
->config_msg
.ROM_start
;
416 target_config
.ROM_size
= in_msg_buf
->config_msg
.ROM_size
;
417 target_config
.max_msg_size
= in_msg_buf
->config_msg
.max_msg_size
;
418 target_config
.max_bkpts
= in_msg_buf
->config_msg
.max_bkpts
;
419 target_config
.coprocessor
= in_msg_buf
->config_msg
.coprocessor
;
420 target_config
.reserved
= in_msg_buf
->config_msg
.reserved
;
423 printf ("Connected to MiniMON :\n");
424 printf (" Debugcore version %d.%d\n",
425 0x0f & (target_config
.version
>> 4),
426 0x0f & (target_config
.version
));
427 printf (" Configuration version %d.%d\n",
428 0x0f & (target_config
.version
>> 12),
429 0x0f & (target_config
.version
>> 8));
430 printf (" Message system version %d.%d\n",
431 0x0f & (target_config
.version
>> 20),
432 0x0f & (target_config
.version
>> 16));
433 printf (" Communication driver version %d.%d\n",
434 0x0f & (target_config
.version
>> 28),
435 0x0f & (target_config
.version
>> 24));
438 /* Leave the target running...
439 * The above message stopped the target in the dbg core (MiniMon),
440 * so restart the target out of MiniMon,
442 out_msg_buf
->go_msg
.code
= GO
;
443 out_msg_buf
->go_msg
.length
= 0;
444 msg_send_serial (out_msg_buf
);
445 /* No message to expect after a GO */
448 /**************************************************************** REMOTE_CLOSE
449 ** Close the open connection to the minimon debugger.
450 Use this when you want to detach and do something else
453 mm_close ( /*FIXME: how is quitting used */
457 error ("Can't close remote connection: not debugging remotely.");
459 /* We should never get here if there isn't something valid in
460 mm_desc and mm_stream.
462 Due to a bug in Unix, fclose closes not only the stdio stream,
463 but also the file descriptor. So we don't actually close
467 /* close (mm_desc); */
469 /* Do not try to close mm_desc again, later in the program. */
473 #if defined (LOG_FILE)
474 if (ferror (log_file
))
475 printf ("Error writing log file.\n");
476 if (fclose (log_file
) != 0)
477 printf ("Error closing log file.\n");
480 printf ("Ending remote debugging\n");
483 /************************************************************* REMOTE_ATACH */
484 /* Attach to a program that is already loaded and running
485 * Upon exiting the process's execution is stopped.
488 mm_attach (char *args
, int from_tty
)
492 error ("MiniMon not opened yet, use the 'target minimon' command.\n");
495 printf ("Attaching to remote program %s...\n", prog_name
);
497 /* Make sure the target is currently running, it is supposed to be. */
498 /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
499 * the dbg core. If so, we don't need to send this GO.
501 out_msg_buf
->go_msg
.code
= GO
;
502 out_msg_buf
->go_msg
.length
= 0;
503 msg_send_serial (out_msg_buf
);
504 sleep (2); /* At the worst it will stop, receive a message, continue */
506 /* Send the mm a break. */
507 out_msg_buf
->break_msg
.code
= BREAK
;
508 out_msg_buf
->break_msg
.length
= 0;
509 msg_send_serial (out_msg_buf
);
511 /********************************************************** REMOTE_DETACH */
512 /* Terminate the open connection to the remote debugger.
513 Use this when you want to detach and do something else
514 with your gdb. Leave remote process running (with no breakpoints set). */
516 mm_detach (char *args
, int from_tty
)
518 remove_breakpoints (); /* Just in case there were any left in */
519 out_msg_buf
->go_msg
.code
= GO
;
520 out_msg_buf
->go_msg
.length
= 0;
521 msg_send_serial (out_msg_buf
);
522 pop_target (); /* calls mm_close to do the real work */
526 /*************************************************************** REMOTE_RESUME
527 ** Tell the remote machine to resume. */
530 mm_resume (int pid
, int step
, enum target_signal sig
)
532 if (sig
!= TARGET_SIGNAL_0
)
533 warning ("Can't send signals to a remote MiniMon system.");
537 out_msg_buf
->step_msg
.code
= STEP
;
538 out_msg_buf
->step_msg
.length
= 1 * 4;
539 out_msg_buf
->step_msg
.count
= 1; /* step 1 instruction */
540 msg_send_serial (out_msg_buf
);
544 out_msg_buf
->go_msg
.code
= GO
;
545 out_msg_buf
->go_msg
.length
= 0;
546 msg_send_serial (out_msg_buf
);
550 /***************************************************************** REMOTE_WAIT
551 ** Wait until the remote machine stops, then return,
552 storing status in STATUS just as `wait' would. */
555 mm_wait (struct target_waitstatus
*status
)
558 int old_timeout
= timeout
;
559 int old_immediate_quit
= immediate_quit
;
561 status
->kind
= TARGET_WAITKIND_EXITED
;
562 status
->value
.integer
= 0;
564 /* wait for message to arrive. It should be:
565 - A HIF service request.
566 - A HIF exit service request.
568 - A CHANNEL1 request.
569 - a debugcore HALT message.
570 HIF services must be responded too, and while-looping continued.
571 If the target stops executing, mm_wait() should return.
573 timeout
= 0; /* Wait indefinetly for a message */
574 immediate_quit
= 1; /* Helps ability to QUIT */
577 while (msg_recv_serial (in_msg_buf
))
579 QUIT
; /* Let user quit if they want */
581 switch (in_msg_buf
->halt_msg
.code
)
584 i
= in_msg_buf
->hif_call_rtn_msg
.service_number
;
585 result
= service_HIF (in_msg_buf
);
586 if (i
== 1) /* EXIT */
589 printf ("Warning: failure during HIF service %d\n", i
);
592 service_HIF (in_msg_buf
);
595 i
= in_msg_buf
->channel1_msg
.length
;
596 in_msg_buf
->channel1_msg
.data
[i
] = '\0';
597 printf ("%s", in_msg_buf
->channel1_msg
.data
);
598 gdb_flush (gdb_stdout
);
599 /* Send CHANNEL1_ACK message */
600 out_msg_buf
->channel1_ack_msg
.code
= CHANNEL1_ACK
;
601 out_msg_buf
->channel1_ack_msg
.length
= 0;
602 result
= msg_send_serial (out_msg_buf
);
611 /* FIXME, these printfs should not be here. This is a source level
613 if (in_msg_buf
->halt_msg
.trap_number
== 0)
615 printf ("Am290*0 received vector number %d (break point)\n",
616 in_msg_buf
->halt_msg
.trap_number
);
617 status
->kind
= TARGET_WAITKIND_STOPPED
;
618 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
620 else if (in_msg_buf
->halt_msg
.trap_number
== 1)
622 printf ("Am290*0 received vector number %d\n",
623 in_msg_buf
->halt_msg
.trap_number
);
624 status
->kind
= TARGET_WAITKIND_STOPPED
;
625 status
->value
.sig
= TARGET_SIGNAL_BUS
;
627 else if (in_msg_buf
->halt_msg
.trap_number
== 3
628 || in_msg_buf
->halt_msg
.trap_number
== 4)
630 printf ("Am290*0 received vector number %d\n",
631 in_msg_buf
->halt_msg
.trap_number
);
632 status
->kind
= TARGET_WAITKIND_STOPPED
;
633 status
->value
.sig
= TARGET_SIGNAL_FPE
;
635 else if (in_msg_buf
->halt_msg
.trap_number
== 5)
637 printf ("Am290*0 received vector number %d\n",
638 in_msg_buf
->halt_msg
.trap_number
);
639 status
->kind
= TARGET_WAITKIND_STOPPED
;
640 status
->value
.sig
= TARGET_SIGNAL_ILL
;
642 else if (in_msg_buf
->halt_msg
.trap_number
>= 6
643 && in_msg_buf
->halt_msg
.trap_number
<= 11)
645 printf ("Am290*0 received vector number %d\n",
646 in_msg_buf
->halt_msg
.trap_number
);
647 status
->kind
= TARGET_WAITKIND_STOPPED
;
648 status
->value
.sig
= TARGET_SIGNAL_SEGV
;
650 else if (in_msg_buf
->halt_msg
.trap_number
== 12
651 || in_msg_buf
->halt_msg
.trap_number
== 13)
653 printf ("Am290*0 received vector number %d\n",
654 in_msg_buf
->halt_msg
.trap_number
);
655 status
->kind
= TARGET_WAITKIND_STOPPED
;
656 status
->value
.sig
= TARGET_SIGNAL_ILL
;
658 else if (in_msg_buf
->halt_msg
.trap_number
== 14)
660 printf ("Am290*0 received vector number %d\n",
661 in_msg_buf
->halt_msg
.trap_number
);
662 status
->kind
= TARGET_WAITKIND_STOPPED
;
663 status
->value
.sig
= TARGET_SIGNAL_ALRM
;
665 else if (in_msg_buf
->halt_msg
.trap_number
== 15)
667 status
->kind
= TARGET_WAITKIND_STOPPED
;
668 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
670 else if (in_msg_buf
->halt_msg
.trap_number
>= 16
671 && in_msg_buf
->halt_msg
.trap_number
<= 21)
673 printf ("Am290*0 received vector number %d\n",
674 in_msg_buf
->halt_msg
.trap_number
);
675 status
->kind
= TARGET_WAITKIND_STOPPED
;
676 status
->value
.sig
= TARGET_SIGNAL_INT
;
678 else if (in_msg_buf
->halt_msg
.trap_number
== 22)
680 printf ("Am290*0 received vector number %d\n",
681 in_msg_buf
->halt_msg
.trap_number
);
682 status
->kind
= TARGET_WAITKIND_STOPPED
;
683 status
->value
.sig
= TARGET_SIGNAL_ILL
;
684 } /* BREAK message was sent */
685 else if (in_msg_buf
->halt_msg
.trap_number
== 75)
687 status
->kind
= TARGET_WAITKIND_STOPPED
;
688 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
693 status
->kind
= TARGET_WAITKIND_EXITED
;
694 status
->value
.integer
= 0;
697 timeout
= old_timeout
; /* Restore original timeout value */
698 immediate_quit
= old_immediate_quit
;
702 /******************************************************* REMOTE_FETCH_REGISTERS
703 * Read a remote register 'regno'.
704 * If regno==-1 then read all the registers.
707 mm_fetch_registers (int regno
)
713 fetch_register (regno
);
718 out_msg_buf
->read_req_msg
.byte_count
= 4 * 1;
719 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
720 out_msg_buf
->read_req_msg
.address
= 1;
721 msg_send_serial (out_msg_buf
);
722 expect_msg (READ_ACK
, in_msg_buf
, 1);
723 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
724 supply_register (GR1_REGNUM
, data_p
);
726 #if defined(GR64_REGNUM) /* Read gr64-127 */
727 /* Global Registers gr64-gr95 */
728 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
729 out_msg_buf
->read_req_msg
.length
= 4 * 3;
730 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
731 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
732 out_msg_buf
->read_req_msg
.address
= 64;
733 msg_send_serial (out_msg_buf
);
734 expect_msg (READ_ACK
, in_msg_buf
, 1);
735 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
737 for (regno
= GR64_REGNUM
; regno
< GR64_REGNUM
+ 32; regno
++)
739 supply_register (regno
, data_p
++);
741 #endif /* GR64_REGNUM */
743 /* Global Registers gr96-gr127 */
744 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
745 out_msg_buf
->read_req_msg
.length
= 4 * 3;
746 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
747 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
748 out_msg_buf
->read_req_msg
.address
= 96;
749 msg_send_serial (out_msg_buf
);
750 expect_msg (READ_ACK
, in_msg_buf
, 1);
751 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
753 for (regno
= GR96_REGNUM
; regno
< GR96_REGNUM
+ 32; regno
++)
755 supply_register (regno
, data_p
++);
758 /* Local Registers */
759 out_msg_buf
->read_req_msg
.byte_count
= 4 * (128);
760 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
761 out_msg_buf
->read_req_msg
.address
= 0;
762 msg_send_serial (out_msg_buf
);
763 expect_msg (READ_ACK
, in_msg_buf
, 1);
764 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
766 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+ 128; regno
++)
768 supply_register (regno
, data_p
++);
771 /* Protected Special Registers */
772 out_msg_buf
->read_req_msg
.byte_count
= 4 * 15;
773 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
774 out_msg_buf
->read_req_msg
.address
= 0;
775 msg_send_serial (out_msg_buf
);
776 expect_msg (READ_ACK
, in_msg_buf
, 1);
777 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
779 for (regno
= 0; regno
<= 14; regno
++)
781 supply_register (SR_REGNUM (regno
), data_p
++);
784 { /* Let regno_to_srnum() handle the register number */
785 fetch_register (NPC_REGNUM
);
786 fetch_register (PC_REGNUM
);
787 fetch_register (PC2_REGNUM
);
790 /* Unprotected Special Registers */
791 out_msg_buf
->read_req_msg
.byte_count
= 4 * 8;
792 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
793 out_msg_buf
->read_req_msg
.address
= 128;
794 msg_send_serial (out_msg_buf
);
795 expect_msg (READ_ACK
, in_msg_buf
, 1);
796 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
798 for (regno
= 128; regno
<= 135; regno
++)
800 supply_register (SR_REGNUM (regno
), data_p
++);
803 /* There doesn't seem to be any way to get these. */
806 supply_register (FPE_REGNUM
, &val
);
807 supply_register (INTE_REGNUM
, &val
);
808 supply_register (FPS_REGNUM
, &val
);
809 supply_register (EXO_REGNUM
, &val
);
814 /****************************************************** REMOTE_STORE_REGISTERS
815 * Store register regno into the target.
816 * If regno==-1 then store all the registers.
817 * Result is 0 for success, -1 for failure.
821 mm_store_registers (int regno
)
827 store_register (regno
);
833 out_msg_buf
->write_r_msg
.code
= WRITE_REQ
;
836 out_msg_buf
->write_r_msg
.byte_count
= 4 * 1;
837 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
838 out_msg_buf
->write_r_msg
.memory_space
= GLOBAL_REG
;
839 out_msg_buf
->write_r_msg
.address
= 1;
840 out_msg_buf
->write_r_msg
.data
[0] = read_register (GR1_REGNUM
);
842 msg_send_serial (out_msg_buf
);
843 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
848 #if defined(GR64_REGNUM)
849 /* Global registers gr64-gr95 */
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
= 64;
854 for (regno
= GR64_REGNUM
; regno
< GR64_REGNUM
+ 32; regno
++)
856 out_msg_buf
->write_r_msg
.data
[regno
- GR64_REGNUM
] = read_register (regno
);
858 msg_send_serial (out_msg_buf
);
859 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
863 #endif /* GR64_REGNUM */
865 /* Global registers gr96-gr127 */
866 out_msg_buf
->write_r_msg
.byte_count
= 4 * (32);
867 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
868 out_msg_buf
->write_r_msg
.address
= 96;
869 for (regno
= GR96_REGNUM
; regno
< GR96_REGNUM
+ 32; regno
++)
871 out_msg_buf
->write_r_msg
.data
[regno
- GR96_REGNUM
] = read_register (regno
);
873 msg_send_serial (out_msg_buf
);
874 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
879 /* Local Registers */
880 out_msg_buf
->write_r_msg
.memory_space
= LOCAL_REG
;
881 out_msg_buf
->write_r_msg
.byte_count
= 4 * 128;
882 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
883 out_msg_buf
->write_r_msg
.address
= 0;
885 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+ 128; regno
++)
887 out_msg_buf
->write_r_msg
.data
[regno
- LR0_REGNUM
] = read_register (regno
);
889 msg_send_serial (out_msg_buf
);
890 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
895 /* Protected Special Registers */
896 /* VAB through TMR */
897 out_msg_buf
->write_r_msg
.memory_space
= SPECIAL_REG
;
898 out_msg_buf
->write_r_msg
.byte_count
= 4 * 10;
899 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
900 out_msg_buf
->write_r_msg
.address
= 0;
901 for (regno
= 0; regno
<= 9; regno
++) /* VAB through TMR */
902 out_msg_buf
->write_r_msg
.data
[regno
] = read_register (SR_REGNUM (regno
));
903 msg_send_serial (out_msg_buf
);
904 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
909 /* PC0, PC1, PC2 possibly as shadow registers */
910 out_msg_buf
->write_r_msg
.byte_count
= 4 * 3;
911 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
912 for (regno
= 10; regno
<= 12; regno
++) /* LRU and MMU */
913 out_msg_buf
->write_r_msg
.data
[regno
- 10] = read_register (SR_REGNUM (regno
));
915 out_msg_buf
->write_r_msg
.address
= 20; /* SPC0 */
917 out_msg_buf
->write_r_msg
.address
= 10; /* PC0 */
918 msg_send_serial (out_msg_buf
);
919 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
925 out_msg_buf
->write_r_msg
.byte_count
= 4 * 2;
926 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
927 out_msg_buf
->write_r_msg
.address
= 13;
928 for (regno
= 13; regno
<= 14; regno
++) /* LRU and MMU */
929 out_msg_buf
->write_r_msg
.data
[regno
- 13] = read_register (SR_REGNUM (regno
));
930 msg_send_serial (out_msg_buf
);
931 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
936 /* Unprotected Special Registers */
937 out_msg_buf
->write_r_msg
.byte_count
= 4 * 8;
938 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
939 out_msg_buf
->write_r_msg
.address
= 128;
940 for (regno
= 128; regno
<= 135; regno
++)
941 out_msg_buf
->write_r_msg
.data
[regno
- 128] = read_register (SR_REGNUM (regno
));
942 msg_send_serial (out_msg_buf
);
943 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
948 registers_changed ();
951 /*************************************************** REMOTE_PREPARE_TO_STORE */
952 /* Get ready to modify the registers array. On machines which store
953 individual registers, this doesn't need to do anything. On machines
954 which store all the registers in one fell swoop, this makes sure
955 that registers contains all the registers from the program being
959 mm_prepare_to_store (void)
961 /* Do nothing, since we can store individual regs */
964 /******************************************************* REMOTE_XFER_MEMORY */
966 translate_addr (CORE_ADDR addr
)
968 #if defined(KERNEL_DEBUGGING)
969 /* Check for a virtual address in the kernel */
970 /* Assume physical address of ublock is in paddr_u register */
971 /* FIXME: doesn't work for user virtual addresses */
974 /* PADDR_U register holds the physical address of the ublock */
975 CORE_ADDR i
= (CORE_ADDR
) read_register (PADDR_U_REGNUM
);
976 return (i
+ addr
- (CORE_ADDR
) UVADDR
);
987 /******************************************************* REMOTE_FILES_INFO */
991 printf ("\tAttached to %s at %d baud and running program %s.\n",
992 dev_name
, baudrate
, prog_name
);
995 /************************************************* REMOTE_INSERT_BREAKPOINT */
997 mm_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
999 out_msg_buf
->bkpt_set_msg
.code
= BKPT_SET
;
1000 out_msg_buf
->bkpt_set_msg
.length
= 4 * 4;
1001 out_msg_buf
->bkpt_set_msg
.memory_space
= I_MEM
;
1002 out_msg_buf
->bkpt_set_msg
.bkpt_addr
= (ADDR32
) addr
;
1003 out_msg_buf
->bkpt_set_msg
.pass_count
= 1;
1004 out_msg_buf
->bkpt_set_msg
.bkpt_type
= -1; /* use illop for 29000 */
1005 msg_send_serial (out_msg_buf
);
1006 if (expect_msg (BKPT_SET_ACK
, in_msg_buf
, 1))
1008 return 0; /* Success */
1012 return 1; /* Failure */
1016 /************************************************* REMOTE_DELETE_BREAKPOINT */
1018 mm_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1020 out_msg_buf
->bkpt_rm_msg
.code
= BKPT_RM
;
1021 out_msg_buf
->bkpt_rm_msg
.length
= 4 * 3;
1022 out_msg_buf
->bkpt_rm_msg
.memory_space
= I_MEM
;
1023 out_msg_buf
->bkpt_rm_msg
.bkpt_addr
= (ADDR32
) addr
;
1024 msg_send_serial (out_msg_buf
);
1025 if (expect_msg (BKPT_RM_ACK
, in_msg_buf
, 1))
1027 return 0; /* Success */
1031 return 1; /* Failure */
1036 /******************************************************* REMOTE_KILL */
1038 mm_kill (char *arg
, int from_tty
)
1042 #if defined(KERNEL_DEBUGGING)
1043 /* We don't ever kill the kernel */
1046 printf ("Kernel not killed, but left in current state.\n");
1047 printf ("Use detach to leave kernel running.\n");
1050 out_msg_buf
->break_msg
.code
= BREAK
;
1051 out_msg_buf
->bkpt_set_msg
.length
= 4 * 0;
1052 expect_msg (HALT
, in_msg_buf
, from_tty
);
1055 printf ("Target has been stopped.");
1056 printf ("Would you like to do a hardware reset (y/n) [n] ");
1057 fgets (buf
, 3, stdin
);
1060 out_msg_buf
->reset_msg
.code
= RESET
;
1061 out_msg_buf
->bkpt_set_msg
.length
= 4 * 0;
1062 expect_msg (RESET_ACK
, in_msg_buf
, from_tty
);
1063 printf ("Target has been reset.");
1072 /***************************************************************************/
1074 * Load a program into the target.
1077 mm_load (char *arg_string
, int from_tty
)
1081 #if defined(KERNEL_DEBUGGING)
1082 printf ("The kernel had better be loaded already! Loading not done.\n");
1084 if (arg_string
== 0)
1085 error ("The load command takes a file name");
1087 arg_string
= tilde_expand (arg_string
);
1088 make_cleanup (xfree
, arg_string
);
1091 error ("File loading is not yet supported for MiniMon.");
1092 /* FIXME, code to load your file here... */
1093 /* You may need to do an init_target_mm() */
1094 /* init_target_mm(?,?,?,?,?,?,?,?); */
1096 /* symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
1101 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1102 ** Copy LEN bytes of data from debugger memory at MYADDR
1103 to inferior's memory at MEMADDR. Returns number of bytes written. */
1105 mm_write_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1109 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1110 out_msg_buf
->write_req_msg
.memory_space
= mm_memory_space (memaddr
);
1113 while (nwritten
< len
)
1115 int num_to_write
= len
- nwritten
;
1116 if (num_to_write
> MAXDATA
)
1117 num_to_write
= MAXDATA
;
1118 for (i
= 0; i
< num_to_write
; i
++)
1119 out_msg_buf
->write_req_msg
.data
[i
] = myaddr
[i
+ nwritten
];
1120 out_msg_buf
->write_req_msg
.byte_count
= num_to_write
;
1121 out_msg_buf
->write_req_msg
.length
= 3 * 4 + num_to_write
;
1122 out_msg_buf
->write_req_msg
.address
= memaddr
+ nwritten
;
1123 msg_send_serial (out_msg_buf
);
1125 if (expect_msg (WRITE_ACK
, in_msg_buf
, 1))
1127 nwritten
+= in_msg_buf
->write_ack_msg
.byte_count
;
1137 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1138 ** Read LEN bytes from inferior memory at MEMADDR. Put the result
1139 at debugger address MYADDR. Returns number of bytes read. */
1141 mm_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
1145 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1146 out_msg_buf
->read_req_msg
.memory_space
= mm_memory_space (memaddr
);
1151 int num_to_read
= (len
- nread
);
1152 if (num_to_read
> MAXDATA
)
1153 num_to_read
= MAXDATA
;
1154 out_msg_buf
->read_req_msg
.byte_count
= num_to_read
;
1155 out_msg_buf
->read_req_msg
.length
= 3 * 4 + num_to_read
;
1156 out_msg_buf
->read_req_msg
.address
= memaddr
+ nread
;
1157 msg_send_serial (out_msg_buf
);
1159 if (expect_msg (READ_ACK
, in_msg_buf
, 1))
1161 for (i
= 0; i
< in_msg_buf
->read_ack_msg
.byte_count
; i
++)
1162 myaddr
[i
+ nread
] = in_msg_buf
->read_ack_msg
.data
[i
];
1163 nread
+= in_msg_buf
->read_ack_msg
.byte_count
;
1173 /* FIXME! Merge these two. */
1175 mm_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int write
,
1176 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
1177 struct target_ops
*target ATTRIBUTE_UNUSED
)
1180 memaddr
= translate_addr (memaddr
);
1183 return mm_write_inferior_memory (memaddr
, myaddr
, len
);
1185 return mm_read_inferior_memory (memaddr
, myaddr
, len
);
1189 /********************************************************** MSG_SEND_SERIAL
1190 ** This function is used to send a message over the
1193 ** If the message is successfully sent, a zero is
1194 ** returned. If the message was not sendable, a -1
1195 ** is returned. This function blocks. That is, it
1196 ** does not return until the message is completely
1197 ** sent, or until an error is encountered.
1202 msg_send_serial (union msg_t
*msg_ptr
)
1209 /* Send message header */
1211 message_size
= msg_ptr
->generic_msg
.length
+ (2 * sizeof (INT32
));
1214 c
= *((char *) msg_ptr
+ byte_count
);
1215 result
= write (mm_desc
, &c
, 1);
1218 byte_count
= byte_count
+ 1;
1221 while ((byte_count
< message_size
));
1224 } /* end msg_send_serial() */
1226 /********************************************************** MSG_RECV_SERIAL
1227 ** This function is used to receive a message over a
1230 ** If the message is waiting in the buffer, a zero is
1231 ** returned and the buffer pointed to by msg_ptr is filled
1232 ** in. If no message was available, a -1 is returned.
1233 ** If timeout==0, wait indefinetly for a character.
1238 msg_recv_serial (union msg_t
*msg_ptr
)
1240 static INT32 length
= 0;
1241 static INT32 byte_count
= 0;
1244 if (msg_ptr
== 0) /* re-sync request */
1249 /* The timeout here is the prevailing timeout set with VTIME */
1250 ->"timeout==0 semantics not supported"
1251 read (mm_desc
, in_buf
, BUFER_SIZE
);
1254 read (mm_desc
, in_buf
, BUFER_SIZE
);
1259 /* Receive message */
1261 /* Timeout==0, help support the mm_wait() routine */
1262 ->"timeout==0 semantics not supported (and its nice if they are)"
1263 result
= read (mm_desc
, &c
, 1);
1266 result
= read (mm_desc
, &c
, 1);
1273 error ("Timeout reading from remote system.");
1276 perror_with_name ("remote");
1278 else if (result
== 1)
1280 *((char *) msg_ptr
+ byte_count
) = c
;
1281 byte_count
= byte_count
+ 1;
1284 /* Message header received. Save message length. */
1285 if (byte_count
== (2 * sizeof (INT32
)))
1286 length
= msg_ptr
->generic_msg
.length
;
1288 if (byte_count
>= (length
+ (2 * sizeof (INT32
))))
1290 /* Message received */
1297 } /* end msg_recv_serial() */
1299 /********************************************************************* KBD_RAW
1300 ** This function is used to put the keyboard in "raw"
1301 ** mode for BSD Unix. The original status is saved
1302 ** so that it may be restored later.
1312 /* Get keyboard termio (to save to restore original modes) */
1314 result
= ioctl (0, TCGETA
, &kbd_tbuf
);
1316 result
= ioctl (0, TIOCGETP
, &kbd_tbuf
);
1321 /* Get keyboard TERMINAL (for modification) */
1323 result
= ioctl (0, TCGETA
, &tbuf
);
1325 result
= ioctl (0, TIOCGETP
, &tbuf
);
1330 /* Set up new parameters */
1332 tbuf
.c_iflag
= tbuf
.c_iflag
&
1333 ~(INLCR
| ICRNL
| IUCLC
| ISTRIP
| IXON
| BRKINT
);
1334 tbuf
.c_lflag
= tbuf
.c_lflag
& ~(ICANON
| ISIG
| ECHO
);
1335 tbuf
.c_cc
[4] = 0; /* MIN */
1336 tbuf
.c_cc
[5] = 0; /* TIME */
1338 /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1339 tbuf
.sg_flags
|= RAW
;
1340 tbuf
.sg_flags
|= ANYP
;
1341 tbuf
.sg_flags
&= ~ECHO
;
1344 /* Set keyboard termio to new mode (RAW) */
1346 result
= ioctl (0, TCSETAF
, &tbuf
);
1348 result
= ioctl (0, TIOCSETP
, &tbuf
);
1354 } /* end kbd_raw() */
1358 /***************************************************************** KBD_RESTORE
1359 ** This function is used to put the keyboard back in the
1360 ** mode it was in before kbk_raw was called. Note that
1361 ** kbk_raw() must have been called at least once before
1362 ** kbd_restore() is called.
1370 /* Set keyboard termio to original mode */
1372 result
= ioctl (0, TCSETAF
, &kbd_tbuf
);
1374 result
= ioctl (0, TIOCGETP
, &kbd_tbuf
);
1381 } /* end kbd_cooked() */
1384 /*****************************************************************************/
1385 /* Fetch a single register indicatated by 'regno'.
1386 * Returns 0/-1 on success/failure.
1389 fetch_register (int regno
)
1392 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1393 out_msg_buf
->read_req_msg
.length
= 4 * 3;
1394 out_msg_buf
->read_req_msg
.byte_count
= 4;
1396 if (regno
== GR1_REGNUM
)
1398 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1399 out_msg_buf
->read_req_msg
.address
= 1;
1401 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1403 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1404 out_msg_buf
->read_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1406 #if defined(GR64_REGNUM)
1407 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32)
1409 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1410 out_msg_buf
->read_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1412 #endif /* GR64_REGNUM */
1413 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1415 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
1416 out_msg_buf
->read_req_msg
.address
= (regno
- LR0_REGNUM
);
1418 else if (regno
>= FPE_REGNUM
&& regno
<= EXO_REGNUM
)
1421 supply_register (160 + (regno
- FPE_REGNUM
), &val
);
1422 return 0; /* Pretend Success */
1426 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
1427 out_msg_buf
->read_req_msg
.address
= regnum_to_srnum (regno
);
1430 msg_send_serial (out_msg_buf
);
1432 if (expect_msg (READ_ACK
, in_msg_buf
, 1))
1434 supply_register (regno
, &(in_msg_buf
->read_r_ack_msg
.data
[0]));
1443 /*****************************************************************************/
1444 /* Store a single register indicated by 'regno'.
1445 * Returns 0/-1 on success/failure.
1448 store_register (int regno
)
1452 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1453 out_msg_buf
->write_req_msg
.length
= 4 * 4;
1454 out_msg_buf
->write_req_msg
.byte_count
= 4;
1455 out_msg_buf
->write_r_msg
.data
[0] = read_register (regno
);
1457 if (regno
== GR1_REGNUM
)
1459 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1460 out_msg_buf
->write_req_msg
.address
= 1;
1461 /* Setting GR1 changes the numbers of all the locals, so invalidate the
1462 * register cache. Do this *after* calling read_register, because we want
1463 * read_register to return the value that write_register has just stuffed
1464 * into the registers array, not the value of the register fetched from
1467 registers_changed ();
1469 #if defined(GR64_REGNUM)
1470 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32)
1472 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1473 out_msg_buf
->write_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1475 #endif /* GR64_REGNUM */
1476 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1478 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1479 out_msg_buf
->write_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1481 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1483 out_msg_buf
->write_req_msg
.memory_space
= LOCAL_REG
;
1484 out_msg_buf
->write_req_msg
.address
= (regno
- LR0_REGNUM
);
1486 else if (regno
>= FPE_REGNUM
&& regno
<= EXO_REGNUM
)
1488 return 0; /* Pretend Success */
1491 /* An unprotected or protected special register */
1493 out_msg_buf
->write_req_msg
.memory_space
= SPECIAL_REG
;
1494 out_msg_buf
->write_req_msg
.address
= regnum_to_srnum (regno
);
1497 msg_send_serial (out_msg_buf
);
1499 if (expect_msg (WRITE_ACK
, in_msg_buf
, 1))
1509 /****************************************************************************/
1511 * Convert a gdb special register number to a 29000 special register number.
1514 regnum_to_srnum (int regno
)
1539 return (USE_SHADOW_PC
? (20) : (10));
1541 return (USE_SHADOW_PC
? (21) : (11));
1543 return (USE_SHADOW_PC
? (22) : (12));
1573 return (255); /* Failure ? */
1576 /****************************************************************************/
1578 * Initialize the target debugger (minimon only).
1581 init_target_mm (ADDR32 tstart
, ADDR32 tend
, ADDR32 dstart
, ADDR32 dend
,
1582 ADDR32 entry
, INT32 ms_size
, INT32 rs_size
, ADDR32 arg_start
)
1584 out_msg_buf
->init_msg
.code
= INIT
;
1585 out_msg_buf
->init_msg
.length
= sizeof (struct init_msg_t
) - 2 * sizeof (INT32
);
1586 out_msg_buf
->init_msg
.text_start
= tstart
;
1587 out_msg_buf
->init_msg
.text_end
= tend
;
1588 out_msg_buf
->init_msg
.data_start
= dstart
;
1589 out_msg_buf
->init_msg
.data_end
= dend
;
1590 out_msg_buf
->init_msg
.entry_point
= entry
;
1591 out_msg_buf
->init_msg
.mem_stack_size
= ms_size
;
1592 out_msg_buf
->init_msg
.reg_stack_size
= rs_size
;
1593 out_msg_buf
->init_msg
.arg_start
= arg_start
;
1594 msg_send_serial (out_msg_buf
);
1595 expect_msg (INIT_ACK
, in_msg_buf
, 1);
1597 /****************************************************************************/
1599 * Return a pointer to a string representing the given message code.
1600 * Not all messages are represented here, only the ones that we expect
1601 * to be called with.
1604 msg_str (INT32 code
)
1606 static char cbuf
[32];
1611 sprintf (cbuf
, "%s (%d)", "BKPT_SET_ACK", code
);
1614 sprintf (cbuf
, "%s (%d)", "BKPT_RM_ACK", code
);
1617 sprintf (cbuf
, "%s (%d)", "INIT_ACK", code
);
1620 sprintf (cbuf
, "%s (%d)", "READ_ACK", code
);
1623 sprintf (cbuf
, "%s (%d)", "WRITE_ACK", code
);
1626 sprintf (cbuf
, "%s (%d)", "ERROR", code
);
1629 sprintf (cbuf
, "%s (%d)", "HALT", code
);
1632 sprintf (cbuf
, "UNKNOWN (%d)", code
);
1637 /****************************************************************************/
1639 * Selected (not all of them) error codes that we might get.
1642 error_msg_str (INT32 code
)
1644 static char cbuf
[50];
1649 return ("EMFAIL: unrecoverable error");
1651 return ("EMBADADDR: Illegal address");
1653 return ("EMBADREG: Illegal register ");
1655 return ("EMACCESS: Could not access memory");
1657 return ("EMBADMSG: Unknown message type");
1659 return ("EMMSG2BIG: Message to large");
1661 return ("EMNOSEND: Could not send message");
1663 return ("EMNORECV: Could not recv message");
1665 return ("EMRESET: Could not RESET target");
1667 return ("EMCONFIG: Could not get target CONFIG");
1669 return ("EMSTATUS: Could not get target STATUS");
1671 return ("EMREAD: Could not READ target memory");
1673 return ("EMWRITE: Could not WRITE target memory");
1675 return ("EMBKPTSET: Could not set breakpoint");
1677 return ("EMBKPTRM: Could not remove breakpoint");
1679 return ("EMBKPTSTAT: Could not get breakpoint status");
1681 return ("EMBKPTNONE: All breakpoints in use");
1683 return ("EMBKPTUSED: Breakpoints already in use");
1685 return ("EMINIT: Could not init target memory");
1687 return ("EMGO: Could not start execution");
1689 return ("EMSTEP: Could not single step");
1691 return ("EMBREAK: Could not BREAK");
1693 return ("EMCOMMERR: Communication error");
1695 sprintf (cbuf
, "error number %d", code
);
1701 /****************************************************************************/
1703 /* Receive a message, placing it in MSG_BUF, and expect it to be of
1704 type MSGCODE. If an error occurs, a non-zero FROM_TTY indicates
1705 that the message should be printed.
1707 Return 0 for failure, 1 for success. */
1710 expect_msg (INT32 msgcode
, union msg_t
*msg_buf
, int from_tty
)
1713 while (msg_recv_serial (msg_buf
) && (retries
++ < MAX_RETRIES
));
1714 if (retries
>= MAX_RETRIES
)
1716 printf ("Expected msg %s, ", msg_str (msgcode
));
1717 printf ("no message received!\n");
1718 return (0); /* Failure */
1721 if (msg_buf
->generic_msg
.code
!= msgcode
)
1725 printf ("Expected msg %s, ", msg_str (msgcode
));
1726 printf ("got msg %s\n", msg_str (msg_buf
->generic_msg
.code
));
1727 if (msg_buf
->generic_msg
.code
== ERROR
)
1728 printf ("%s\n", error_msg_str (msg_buf
->error_msg
.error_code
));
1730 return (0); /* Failure */
1732 return (1); /* Success */
1734 /****************************************************************************/
1736 * Determine the MiniMon memory space qualifier based on the addr.
1737 * FIXME: Can't distinguis I_ROM/D_ROM.
1738 * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1741 mm_memory_space (CORE_ADDR
*addr
)
1743 ADDR32 tstart
= target_config
.I_mem_start
;
1744 ADDR32 tend
= tstart
+ target_config
.I_mem_size
;
1745 ADDR32 dstart
= target_config
.D_mem_start
;
1746 ADDR32 dend
= tstart
+ target_config
.D_mem_size
;
1747 ADDR32 rstart
= target_config
.ROM_start
;
1748 ADDR32 rend
= tstart
+ target_config
.ROM_size
;
1750 if (((ADDR32
) addr
>= tstart
) && ((ADDR32
) addr
< tend
))
1754 else if (((ADDR32
) addr
>= dstart
) && ((ADDR32
) addr
< dend
))
1758 else if (((ADDR32
) addr
>= rstart
) && ((ADDR32
) addr
< rend
))
1760 /* FIXME: how do we determine between D_ROM and I_ROM */
1763 else /* FIXME: what do me do now? */
1764 return D_MEM
; /* Hmmm! */
1767 /****************************************************************************/
1769 * Define the target subroutine names
1771 struct target_ops mm_ops
;
1776 mm_ops
.to_shortname
= "minimon";
1777 mm_ops
.to_longname
= "Remote AMD/Minimon target";
1778 mm_ops
.to_doc
= "Remote debug an AMD 290*0 using the MiniMon dbg core on the target";
1779 mm_ops
.to_open
= mm_open
;
1780 mm_ops
.to_close
= mm_close
;
1781 mm_ops
.to_attach
= mm_attach
;
1782 mm_ops
.to_post_attach
= NULL
;
1783 mm_ops
.to_require_attach
= NULL
;
1784 mm_ops
.to_detach
= mm_detach
;
1785 mm_ops
.to_require_detach
= NULL
;
1786 mm_ops
.to_resume
= mm_resume
;
1787 mm_ops
.to_wait
= mm_wait
;
1788 mm_ops
.to_post_wait
= NULL
;
1789 mm_ops
.to_fetch_registers
= mm_fetch_registers
;
1790 mm_ops
.to_store_registers
= mm_store_registers
;
1791 mm_ops
.to_prepare_to_store
= mm_prepare_to_store
;
1792 mm_ops
.to_xfer_memory
= mm_xfer_inferior_memory
;
1793 mm_ops
.to_files_info
= mm_files_info
;
1794 mm_ops
.to_insert_breakpoint
= mm_insert_breakpoint
;
1795 mm_ops
.to_remove_breakpoint
= mm_remove_breakpoint
;
1796 mm_ops
.to_terminal_init
= 0;
1797 mm_ops
.to_terminal_inferior
= 0;
1798 mm_ops
.to_terminal_ours_for_output
= 0;
1799 mm_ops
.to_terminal_ours
= 0;
1800 mm_ops
.to_terminal_info
= 0;
1801 mm_ops
.to_kill
= mm_kill
;
1802 mm_ops
.to_load
= mm_load
;
1803 mm_ops
.to_lookup_symbol
= 0;
1804 mm_ops
.to_create_inferior
= mm_create_inferior
;
1805 mm_ops
.to_post_startup_inferior
= NULL
;
1806 mm_ops
.to_acknowledge_created_inferior
= NULL
;
1807 mm_ops
.to_clone_and_follow_inferior
= NULL
;
1808 mm_ops
.to_post_follow_inferior_by_clone
= NULL
;
1809 mm_ops
.to_insert_fork_catchpoint
= NULL
;
1810 mm_ops
.to_remove_fork_catchpoint
= NULL
;
1811 mm_ops
.to_insert_vfork_catchpoint
= NULL
;
1812 mm_ops
.to_remove_vfork_catchpoint
= NULL
;
1813 mm_ops
.to_has_forked
= NULL
;
1814 mm_ops
.to_has_vforked
= NULL
;
1815 mm_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
1816 mm_ops
.to_post_follow_vfork
= NULL
;
1817 mm_ops
.to_insert_exec_catchpoint
= NULL
;
1818 mm_ops
.to_remove_exec_catchpoint
= NULL
;
1819 mm_ops
.to_has_execd
= NULL
;
1820 mm_ops
.to_reported_exec_events_per_exec_call
= NULL
;
1821 mm_ops
.to_has_exited
= NULL
;
1822 mm_ops
.to_mourn_inferior
= mm_mourn
;
1823 mm_ops
.to_can_run
= 0;
1824 mm_ops
.to_notice_signals
= 0;
1825 mm_ops
.to_thread_alive
= 0;
1827 mm_ops
.to_pid_to_exec_file
= NULL
;
1828 mm_ops
.to_core_file_to_sym_file
= NULL
;
1829 mm_ops
.to_stratum
= process_stratum
;
1830 mm_ops
.DONT_USE
= 0;
1831 mm_ops
.to_has_all_memory
= 1;
1832 mm_ops
.to_has_memory
= 1;
1833 mm_ops
.to_has_stack
= 1;
1834 mm_ops
.to_has_registers
= 1;
1835 mm_ops
.to_has_execution
= 1;
1836 mm_ops
.to_sections
= 0;
1837 mm_ops
.to_sections_end
= 0;
1838 mm_ops
.to_magic
= OPS_MAGIC
;
1842 _initialize_remote_mm (void)
1845 add_target (&mm_ops
);
1848 #ifdef NO_HIF_SUPPORT
1849 service_HIF (union msg_t
*msg
)
1851 return (0); /* Emulate a failure */