1 /* Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Originally written by Daniel Mann at AMD.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 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
41 #include "gdb_string.h"
46 /* Offset of member MEMBER in a struct of type TYPE. */
47 #define offsetof(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)
49 #define DRAIN_INPUT() (msg_recv_serial((union msg_t*)0))
51 extern int stop_soon_quietly
; /* for wait_for_inferior */
53 static void mm_resume ();
54 static void mm_fetch_registers ();
55 static int fetch_register ();
56 static void mm_store_registers ();
57 static int store_register ();
58 static int regnum_to_srnum ();
59 static void mm_close ();
60 static char *msg_str ();
61 static char *error_msg_str ();
62 static int expect_msg ();
63 static void init_target_mm ();
64 static int mm_memory_space ();
66 #define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
67 #define USE_SHADOW_PC ((processor_type == a29k_freeze_mode) && FREEZE_MODE)
69 /* FIXME: Replace with `set remotedebug'. */
70 #define LLOG_FILE "minimon.log"
71 #if defined (LOG_FILE)
76 * Size of message buffers. I couldn't get memory reads to work when
77 * the byte_count was larger than 512 (it may be a baud rate problem).
79 #define BUFER_SIZE 512
81 * Size of data area in message buffer on the TARGET (remote system).
83 #define MAXDATA_T (target_config.max_msg_size - \
84 offsetof(struct write_r_msg_t,data[0]))
86 * Size of data area in message buffer on the HOST (gdb).
88 #define MAXDATA_H (BUFER_SIZE - offsetof(struct write_r_msg_t,data[0]))
90 * Defined as the minimum size of data areas of the two message buffers
92 #define MAXDATA (MAXDATA_H < MAXDATA_T ? MAXDATA_H : MAXDATA_T)
94 static char out_buf
[BUFER_SIZE
];
95 static char in_buf
[BUFER_SIZE
];
97 int msg_recv_serial ();
98 int msg_send_serial ();
100 #define MAX_RETRIES 5000
101 extern struct target_ops mm_ops
; /* Forward declaration */
102 struct config_msg_t target_config
; /* HIF needs this */
103 union msg_t
*out_msg_buf
= (union msg_t
*) out_buf
;
104 union msg_t
*in_msg_buf
= (union msg_t
*) in_buf
;
106 static int timeout
= 5;
108 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
109 mm_open knows that we don't have a file open when the program
113 /* stream which is fdopen'd from mm_desc. Only valid when
117 /* Called when SIGALRM signal sent due to alarm() timeout. */
126 volatile int n_alarms
;
133 printf ("mm_timer called\n");
137 #endif /* HAVE_TERMIO */
139 /* malloc'd name of the program on the remote system. */
140 static char *prog_name
= NULL
;
143 /* Number of SIGTRAPs we need to simulate. That is, the next
144 NEED_ARTIFICIAL_TRAP calls to mm_wait should just return
145 SIGTRAP without actually waiting for anything. */
147 /**************************************************** REMOTE_CREATE_INFERIOR */
148 /* This is called not only when we first attach, but also when the
149 user types "run" after having attached. */
151 mm_create_inferior (execfile
, args
, env
)
156 #define MAX_TOKENS 25
157 #define BUFFER_SIZE 256
160 char *token
[MAX_TOKENS
];
161 char cmd_line
[BUFFER_SIZE
];
164 error ("Can't pass arguments to remote mm process (yet).");
166 if (execfile
== 0 /* || exec_bfd == 0 */ )
167 error ("No executable file specified");
171 printf ("Minimon not open yet.\n");
175 /* On ultra3 (NYU) we assume the kernel is already running so there is
177 FIXME: Fixed required here -> load your program, possibly with mm_load().
179 printf_filtered ("\n\
180 Assuming you are at NYU debuging a kernel, i.e., no need to download.\n\n");
182 /* We will get a task spawn event immediately. */
183 init_wait_for_inferior ();
184 clear_proceed_status ();
185 stop_soon_quietly
= 1;
186 proceed (-1, TARGET_SIGNAL_DEFAULT
, 0);
189 /**************************************************** REMOTE_MOURN_INFERIOR */
193 pop_target (); /* Pop back to no-child state */
194 generic_mourn_inferior ();
197 /********************************************************************** damn_b
199 /* Translate baud rates from integers to damn B_codes. Unix should
200 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
291 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
292 if (rate
== baudtab
[i
].rate
)
293 return baudtab
[i
].damn_b
;
294 return B38400
; /* Random */
298 /***************************************************************** REMOTE_OPEN
299 ** Open a connection to remote minimon.
300 NAME is the filename used for communication, then a space,
302 'target adapt /dev/ttya 9600 [prognam]' for example.
305 static char *dev_name
;
308 mm_open (name
, from_tty
)
316 /* Find the first whitespace character, it separates dev_name from
319 p
&& *p
&& !isspace (*p
); p
++)
321 if (p
== 0 || *p
== '\0')
323 error ("Usage : <command> <serial-device> <baud-rate> [progname]");
324 dev_name
= (char *) xmalloc (p
- name
+ 1);
325 strncpy (dev_name
, name
, p
- name
);
326 dev_name
[p
- name
] = '\0';
328 /* Skip over the whitespace after dev_name */
329 for (; isspace (*p
); p
++)
332 if (1 != sscanf (p
, "%d ", &baudrate
))
335 /* Skip the number and then the spaces */
336 for (; isdigit (*p
); p
++)
338 for (; isspace (*p
); p
++)
341 if (prog_name
!= NULL
)
343 prog_name
= savestring (p
, strlen (p
));
349 mm_desc
= open (dev_name
, O_RDWR
);
351 perror_with_name (dev_name
);
352 ioctl (mm_desc
, TIOCGETP
, &sg
);
354 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
355 sg
.c_cc
[VTIME
] = timeout
* 10;
356 sg
.c_lflag
&= ~(ICANON
| ECHO
);
357 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
359 sg
.sg_ispeed
= damn_b (baudrate
);
360 sg
.sg_ospeed
= damn_b (baudrate
);
363 sg
.sg_flags
&= ~ECHO
;
367 ioctl (mm_desc
, TIOCSETP
, &sg
);
368 mm_stream
= fdopen (mm_desc
, "r+");
370 push_target (&mm_ops
);
373 #ifndef NO_SIGINTERRUPT
374 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
376 if (siginterrupt (SIGALRM
, 1) != 0)
377 perror ("mm_open: error in siginterrupt");
380 /* Set up read timeout timer. */
381 if ((void (*)) signal (SIGALRM
, mm_timer
) == (void (*)) -1)
382 perror ("mm_open: error in signal");
385 #if defined (LOG_FILE)
386 log_file
= fopen (LOG_FILE
, "w");
387 if (log_file
== NULL
)
388 perror_with_name (LOG_FILE
);
391 ** Initialize target configuration structure (global)
394 out_msg_buf
->config_req_msg
.code
= CONFIG_REQ
;
395 out_msg_buf
->config_req_msg
.length
= 4 * 0;
396 msg_send_serial (out_msg_buf
); /* send config request message */
398 expect_msg (CONFIG
, in_msg_buf
, 1);
400 a29k_get_processor_type ();
402 /* Print out some stuff, letting the user now what's going on */
403 printf_filtered ("Connected to MiniMon via %s.\n", dev_name
);
404 /* FIXME: can this restriction be removed? */
405 printf_filtered ("Remote debugging using virtual addresses works only\n");
406 printf_filtered ("\twhen virtual addresses map 1:1 to physical addresses.\n")
408 if (processor_type
!= a29k_freeze_mode
)
410 fprintf_filtered (gdb_stderr
,
411 "Freeze-mode debugging not available, and can only be done on an A29050.\n");
414 target_config
.code
= CONFIG
;
415 target_config
.length
= 0;
416 target_config
.processor_id
= in_msg_buf
->config_msg
.processor_id
;
417 target_config
.version
= in_msg_buf
->config_msg
.version
;
418 target_config
.I_mem_start
= in_msg_buf
->config_msg
.I_mem_start
;
419 target_config
.I_mem_size
= in_msg_buf
->config_msg
.I_mem_size
;
420 target_config
.D_mem_start
= in_msg_buf
->config_msg
.D_mem_start
;
421 target_config
.D_mem_size
= in_msg_buf
->config_msg
.D_mem_size
;
422 target_config
.ROM_start
= in_msg_buf
->config_msg
.ROM_start
;
423 target_config
.ROM_size
= in_msg_buf
->config_msg
.ROM_size
;
424 target_config
.max_msg_size
= in_msg_buf
->config_msg
.max_msg_size
;
425 target_config
.max_bkpts
= in_msg_buf
->config_msg
.max_bkpts
;
426 target_config
.coprocessor
= in_msg_buf
->config_msg
.coprocessor
;
427 target_config
.reserved
= in_msg_buf
->config_msg
.reserved
;
430 printf ("Connected to MiniMON :\n");
431 printf (" Debugcore version %d.%d\n",
432 0x0f & (target_config
.version
>> 4),
433 0x0f & (target_config
.version
));
434 printf (" Configuration version %d.%d\n",
435 0x0f & (target_config
.version
>> 12),
436 0x0f & (target_config
.version
>> 8));
437 printf (" Message system version %d.%d\n",
438 0x0f & (target_config
.version
>> 20),
439 0x0f & (target_config
.version
>> 16));
440 printf (" Communication driver version %d.%d\n",
441 0x0f & (target_config
.version
>> 28),
442 0x0f & (target_config
.version
>> 24));
445 /* Leave the target running...
446 * The above message stopped the target in the dbg core (MiniMon),
447 * so restart the target out of MiniMon,
449 out_msg_buf
->go_msg
.code
= GO
;
450 out_msg_buf
->go_msg
.length
= 0;
451 msg_send_serial (out_msg_buf
);
452 /* No message to expect after a GO */
455 /**************************************************************** REMOTE_CLOSE
456 ** Close the open connection to the minimon debugger.
457 Use this when you want to detach and do something else
460 mm_close (quitting
) /*FIXME: how is quitting used */
464 error ("Can't close remote connection: not debugging remotely.");
466 /* We should never get here if there isn't something valid in
467 mm_desc and mm_stream.
469 Due to a bug in Unix, fclose closes not only the stdio stream,
470 but also the file descriptor. So we don't actually close
474 /* close (mm_desc); */
476 /* Do not try to close mm_desc again, later in the program. */
480 #if defined (LOG_FILE)
481 if (ferror (log_file
))
482 printf ("Error writing log file.\n");
483 if (fclose (log_file
) != 0)
484 printf ("Error closing log file.\n");
487 printf ("Ending remote debugging\n");
490 /************************************************************* REMOTE_ATACH */
491 /* Attach to a program that is already loaded and running
492 * Upon exiting the process's execution is stopped.
495 mm_attach (args
, from_tty
)
501 error ("MiniMon not opened yet, use the 'target minimon' command.\n");
504 printf ("Attaching to remote program %s...\n", prog_name
);
506 /* Make sure the target is currently running, it is supposed to be. */
507 /* FIXME: is it ok to send MiniMon a BREAK if it is already stopped in
508 * the dbg core. If so, we don't need to send this GO.
510 out_msg_buf
->go_msg
.code
= GO
;
511 out_msg_buf
->go_msg
.length
= 0;
512 msg_send_serial (out_msg_buf
);
513 sleep (2); /* At the worst it will stop, receive a message, continue */
515 /* Send the mm a break. */
516 out_msg_buf
->break_msg
.code
= BREAK
;
517 out_msg_buf
->break_msg
.length
= 0;
518 msg_send_serial (out_msg_buf
);
520 /********************************************************** REMOTE_DETACH */
521 /* Terminate the open connection to the remote debugger.
522 Use this when you want to detach and do something else
523 with your gdb. Leave remote process running (with no breakpoints set). */
525 mm_detach (args
, from_tty
)
529 remove_breakpoints (); /* Just in case there were any left in */
530 out_msg_buf
->go_msg
.code
= GO
;
531 out_msg_buf
->go_msg
.length
= 0;
532 msg_send_serial (out_msg_buf
);
533 pop_target (); /* calls mm_close to do the real work */
537 /*************************************************************** REMOTE_RESUME
538 ** Tell the remote machine to resume. */
541 mm_resume (pid
, step
, sig
)
543 enum target_signal sig
;
545 if (sig
!= TARGET_SIGNAL_0
)
546 warning ("Can't send signals to a remote MiniMon system.");
550 out_msg_buf
->step_msg
.code
= STEP
;
551 out_msg_buf
->step_msg
.length
= 1 * 4;
552 out_msg_buf
->step_msg
.count
= 1; /* step 1 instruction */
553 msg_send_serial (out_msg_buf
);
557 out_msg_buf
->go_msg
.code
= GO
;
558 out_msg_buf
->go_msg
.length
= 0;
559 msg_send_serial (out_msg_buf
);
563 /***************************************************************** REMOTE_WAIT
564 ** Wait until the remote machine stops, then return,
565 storing status in STATUS just as `wait' would. */
569 struct target_waitstatus
*status
;
572 int old_timeout
= timeout
;
573 int old_immediate_quit
= immediate_quit
;
575 status
->kind
= TARGET_WAITKIND_EXITED
;
576 status
->value
.integer
= 0;
578 /* wait for message to arrive. It should be:
579 - A HIF service request.
580 - A HIF exit service request.
582 - A CHANNEL1 request.
583 - a debugcore HALT message.
584 HIF services must be responded too, and while-looping continued.
585 If the target stops executing, mm_wait() should return.
587 timeout
= 0; /* Wait indefinetly for a message */
588 immediate_quit
= 1; /* Helps ability to QUIT */
591 while (msg_recv_serial (in_msg_buf
))
593 QUIT
; /* Let user quit if they want */
595 switch (in_msg_buf
->halt_msg
.code
)
598 i
= in_msg_buf
->hif_call_rtn_msg
.service_number
;
599 result
= service_HIF (in_msg_buf
);
600 if (i
== 1) /* EXIT */
603 printf ("Warning: failure during HIF service %d\n", i
);
606 service_HIF (in_msg_buf
);
609 i
= in_msg_buf
->channel1_msg
.length
;
610 in_msg_buf
->channel1_msg
.data
[i
] = '\0';
611 printf ("%s", in_msg_buf
->channel1_msg
.data
);
612 gdb_flush (gdb_stdout
);
613 /* Send CHANNEL1_ACK message */
614 out_msg_buf
->channel1_ack_msg
.code
= CHANNEL1_ACK
;
615 out_msg_buf
->channel1_ack_msg
.length
= 0;
616 result
= msg_send_serial (out_msg_buf
);
625 /* FIXME, these printfs should not be here. This is a source level
627 if (in_msg_buf
->halt_msg
.trap_number
== 0)
629 printf ("Am290*0 received vector number %d (break point)\n",
630 in_msg_buf
->halt_msg
.trap_number
);
631 status
->kind
= TARGET_WAITKIND_STOPPED
;
632 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
634 else if (in_msg_buf
->halt_msg
.trap_number
== 1)
636 printf ("Am290*0 received vector number %d\n",
637 in_msg_buf
->halt_msg
.trap_number
);
638 status
->kind
= TARGET_WAITKIND_STOPPED
;
639 status
->value
.sig
= TARGET_SIGNAL_BUS
;
641 else if (in_msg_buf
->halt_msg
.trap_number
== 3
642 || in_msg_buf
->halt_msg
.trap_number
== 4)
644 printf ("Am290*0 received vector number %d\n",
645 in_msg_buf
->halt_msg
.trap_number
);
646 status
->kind
= TARGET_WAITKIND_STOPPED
;
647 status
->value
.sig
= TARGET_SIGNAL_FPE
;
649 else if (in_msg_buf
->halt_msg
.trap_number
== 5)
651 printf ("Am290*0 received vector number %d\n",
652 in_msg_buf
->halt_msg
.trap_number
);
653 status
->kind
= TARGET_WAITKIND_STOPPED
;
654 status
->value
.sig
= TARGET_SIGNAL_ILL
;
656 else if (in_msg_buf
->halt_msg
.trap_number
>= 6
657 && in_msg_buf
->halt_msg
.trap_number
<= 11)
659 printf ("Am290*0 received vector number %d\n",
660 in_msg_buf
->halt_msg
.trap_number
);
661 status
->kind
= TARGET_WAITKIND_STOPPED
;
662 status
->value
.sig
= TARGET_SIGNAL_SEGV
;
664 else if (in_msg_buf
->halt_msg
.trap_number
== 12
665 || in_msg_buf
->halt_msg
.trap_number
== 13)
667 printf ("Am290*0 received vector number %d\n",
668 in_msg_buf
->halt_msg
.trap_number
);
669 status
->kind
= TARGET_WAITKIND_STOPPED
;
670 status
->value
.sig
= TARGET_SIGNAL_ILL
;
672 else if (in_msg_buf
->halt_msg
.trap_number
== 14)
674 printf ("Am290*0 received vector number %d\n",
675 in_msg_buf
->halt_msg
.trap_number
);
676 status
->kind
= TARGET_WAITKIND_STOPPED
;
677 status
->value
.sig
= TARGET_SIGNAL_ALRM
;
679 else if (in_msg_buf
->halt_msg
.trap_number
== 15)
681 status
->kind
= TARGET_WAITKIND_STOPPED
;
682 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
684 else if (in_msg_buf
->halt_msg
.trap_number
>= 16
685 && in_msg_buf
->halt_msg
.trap_number
<= 21)
687 printf ("Am290*0 received vector number %d\n",
688 in_msg_buf
->halt_msg
.trap_number
);
689 status
->kind
= TARGET_WAITKIND_STOPPED
;
690 status
->value
.sig
= TARGET_SIGNAL_INT
;
692 else if (in_msg_buf
->halt_msg
.trap_number
== 22)
694 printf ("Am290*0 received vector number %d\n",
695 in_msg_buf
->halt_msg
.trap_number
);
696 status
->kind
= TARGET_WAITKIND_STOPPED
;
697 status
->value
.sig
= TARGET_SIGNAL_ILL
;
698 } /* BREAK message was sent */
699 else if (in_msg_buf
->halt_msg
.trap_number
== 75)
701 status
->kind
= TARGET_WAITKIND_STOPPED
;
702 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
707 status
->kind
= TARGET_WAITKIND_EXITED
;
708 status
->value
.integer
= 0;
711 timeout
= old_timeout
; /* Restore original timeout value */
712 immediate_quit
= old_immediate_quit
;
716 /******************************************************* REMOTE_FETCH_REGISTERS
717 * Read a remote register 'regno'.
718 * If regno==-1 then read all the registers.
721 mm_fetch_registers (regno
)
728 fetch_register (regno
);
733 out_msg_buf
->read_req_msg
.byte_count
= 4 * 1;
734 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
735 out_msg_buf
->read_req_msg
.address
= 1;
736 msg_send_serial (out_msg_buf
);
737 expect_msg (READ_ACK
, in_msg_buf
, 1);
738 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
739 supply_register (GR1_REGNUM
, data_p
);
741 #if defined(GR64_REGNUM) /* Read gr64-127 */
742 /* Global Registers gr64-gr95 */
743 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
744 out_msg_buf
->read_req_msg
.length
= 4 * 3;
745 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
746 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
747 out_msg_buf
->read_req_msg
.address
= 64;
748 msg_send_serial (out_msg_buf
);
749 expect_msg (READ_ACK
, in_msg_buf
, 1);
750 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
752 for (regno
= GR64_REGNUM
; regno
< GR64_REGNUM
+ 32; regno
++)
754 supply_register (regno
, data_p
++);
756 #endif /* GR64_REGNUM */
758 /* Global Registers gr96-gr127 */
759 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
760 out_msg_buf
->read_req_msg
.length
= 4 * 3;
761 out_msg_buf
->read_req_msg
.byte_count
= 4 * 32;
762 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
763 out_msg_buf
->read_req_msg
.address
= 96;
764 msg_send_serial (out_msg_buf
);
765 expect_msg (READ_ACK
, in_msg_buf
, 1);
766 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
768 for (regno
= GR96_REGNUM
; regno
< GR96_REGNUM
+ 32; regno
++)
770 supply_register (regno
, data_p
++);
773 /* Local Registers */
774 out_msg_buf
->read_req_msg
.byte_count
= 4 * (128);
775 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
776 out_msg_buf
->read_req_msg
.address
= 0;
777 msg_send_serial (out_msg_buf
);
778 expect_msg (READ_ACK
, in_msg_buf
, 1);
779 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
781 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+ 128; regno
++)
783 supply_register (regno
, data_p
++);
786 /* Protected Special Registers */
787 out_msg_buf
->read_req_msg
.byte_count
= 4 * 15;
788 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
789 out_msg_buf
->read_req_msg
.address
= 0;
790 msg_send_serial (out_msg_buf
);
791 expect_msg (READ_ACK
, in_msg_buf
, 1);
792 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
794 for (regno
= 0; regno
<= 14; regno
++)
796 supply_register (SR_REGNUM (regno
), data_p
++);
799 { /* Let regno_to_srnum() handle the register number */
800 fetch_register (NPC_REGNUM
);
801 fetch_register (PC_REGNUM
);
802 fetch_register (PC2_REGNUM
);
805 /* Unprotected Special Registers */
806 out_msg_buf
->read_req_msg
.byte_count
= 4 * 8;
807 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
808 out_msg_buf
->read_req_msg
.address
= 128;
809 msg_send_serial (out_msg_buf
);
810 expect_msg (READ_ACK
, in_msg_buf
, 1);
811 data_p
= &(in_msg_buf
->read_r_ack_msg
.data
[0]);
813 for (regno
= 128; regno
<= 135; regno
++)
815 supply_register (SR_REGNUM (regno
), data_p
++);
818 /* There doesn't seem to be any way to get these. */
821 supply_register (FPE_REGNUM
, &val
);
822 supply_register (INTE_REGNUM
, &val
);
823 supply_register (FPS_REGNUM
, &val
);
824 supply_register (EXO_REGNUM
, &val
);
829 /****************************************************** REMOTE_STORE_REGISTERS
830 * Store register regno into the target.
831 * If regno==-1 then store all the registers.
832 * Result is 0 for success, -1 for failure.
836 mm_store_registers (regno
)
843 store_register (regno
);
849 out_msg_buf
->write_r_msg
.code
= WRITE_REQ
;
852 out_msg_buf
->write_r_msg
.byte_count
= 4 * 1;
853 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
854 out_msg_buf
->write_r_msg
.memory_space
= GLOBAL_REG
;
855 out_msg_buf
->write_r_msg
.address
= 1;
856 out_msg_buf
->write_r_msg
.data
[0] = read_register (GR1_REGNUM
);
858 msg_send_serial (out_msg_buf
);
859 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
864 #if defined(GR64_REGNUM)
865 /* Global registers gr64-gr95 */
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
= 64;
870 for (regno
= GR64_REGNUM
; regno
< GR64_REGNUM
+ 32; regno
++)
872 out_msg_buf
->write_r_msg
.data
[regno
- GR64_REGNUM
] = read_register (regno
);
874 msg_send_serial (out_msg_buf
);
875 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
879 #endif /* GR64_REGNUM */
881 /* Global registers gr96-gr127 */
882 out_msg_buf
->write_r_msg
.byte_count
= 4 * (32);
883 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
884 out_msg_buf
->write_r_msg
.address
= 96;
885 for (regno
= GR96_REGNUM
; regno
< GR96_REGNUM
+ 32; regno
++)
887 out_msg_buf
->write_r_msg
.data
[regno
- GR96_REGNUM
] = read_register (regno
);
889 msg_send_serial (out_msg_buf
);
890 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
895 /* Local Registers */
896 out_msg_buf
->write_r_msg
.memory_space
= LOCAL_REG
;
897 out_msg_buf
->write_r_msg
.byte_count
= 4 * 128;
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
= 0;
901 for (regno
= LR0_REGNUM
; regno
< LR0_REGNUM
+ 128; regno
++)
903 out_msg_buf
->write_r_msg
.data
[regno
- LR0_REGNUM
] = read_register (regno
);
905 msg_send_serial (out_msg_buf
);
906 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
911 /* Protected Special Registers */
912 /* VAB through TMR */
913 out_msg_buf
->write_r_msg
.memory_space
= SPECIAL_REG
;
914 out_msg_buf
->write_r_msg
.byte_count
= 4 * 10;
915 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
916 out_msg_buf
->write_r_msg
.address
= 0;
917 for (regno
= 0; regno
<= 9; regno
++) /* VAB through TMR */
918 out_msg_buf
->write_r_msg
.data
[regno
] = read_register (SR_REGNUM (regno
));
919 msg_send_serial (out_msg_buf
);
920 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
925 /* PC0, PC1, PC2 possibly as shadow registers */
926 out_msg_buf
->write_r_msg
.byte_count
= 4 * 3;
927 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
928 for (regno
= 10; regno
<= 12; regno
++) /* LRU and MMU */
929 out_msg_buf
->write_r_msg
.data
[regno
- 10] = read_register (SR_REGNUM (regno
));
931 out_msg_buf
->write_r_msg
.address
= 20; /* SPC0 */
933 out_msg_buf
->write_r_msg
.address
= 10; /* PC0 */
934 msg_send_serial (out_msg_buf
);
935 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
941 out_msg_buf
->write_r_msg
.byte_count
= 4 * 2;
942 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
943 out_msg_buf
->write_r_msg
.address
= 13;
944 for (regno
= 13; regno
<= 14; regno
++) /* LRU and MMU */
945 out_msg_buf
->write_r_msg
.data
[regno
- 13] = read_register (SR_REGNUM (regno
));
946 msg_send_serial (out_msg_buf
);
947 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
952 /* Unprotected Special Registers */
953 out_msg_buf
->write_r_msg
.byte_count
= 4 * 8;
954 out_msg_buf
->write_r_msg
.length
= 3 * 4 + out_msg_buf
->write_r_msg
.byte_count
;
955 out_msg_buf
->write_r_msg
.address
= 128;
956 for (regno
= 128; regno
<= 135; regno
++)
957 out_msg_buf
->write_r_msg
.data
[regno
- 128] = read_register (SR_REGNUM (regno
));
958 msg_send_serial (out_msg_buf
);
959 if (!expect_msg (WRITE_ACK
, in_msg_buf
, 1))
964 registers_changed ();
967 /*************************************************** REMOTE_PREPARE_TO_STORE */
968 /* Get ready to modify the registers array. On machines which store
969 individual registers, this doesn't need to do anything. On machines
970 which store all the registers in one fell swoop, this makes sure
971 that registers contains all the registers from the program being
975 mm_prepare_to_store ()
977 /* Do nothing, since we can store individual regs */
980 /******************************************************* REMOTE_XFER_MEMORY */
982 translate_addr (addr
)
985 #if defined(KERNEL_DEBUGGING)
986 /* Check for a virtual address in the kernel */
987 /* Assume physical address of ublock is in paddr_u register */
988 /* FIXME: doesn't work for user virtual addresses */
991 /* PADDR_U register holds the physical address of the ublock */
992 CORE_ADDR i
= (CORE_ADDR
) read_register (PADDR_U_REGNUM
);
993 return (i
+ addr
- (CORE_ADDR
) UVADDR
);
1004 /******************************************************* REMOTE_FILES_INFO */
1008 printf ("\tAttached to %s at %d baud and running program %s.\n",
1009 dev_name
, baudrate
, prog_name
);
1012 /************************************************* REMOTE_INSERT_BREAKPOINT */
1014 mm_insert_breakpoint (addr
, contents_cache
)
1016 char *contents_cache
;
1018 out_msg_buf
->bkpt_set_msg
.code
= BKPT_SET
;
1019 out_msg_buf
->bkpt_set_msg
.length
= 4 * 4;
1020 out_msg_buf
->bkpt_set_msg
.memory_space
= I_MEM
;
1021 out_msg_buf
->bkpt_set_msg
.bkpt_addr
= (ADDR32
) addr
;
1022 out_msg_buf
->bkpt_set_msg
.pass_count
= 1;
1023 out_msg_buf
->bkpt_set_msg
.bkpt_type
= -1; /* use illop for 29000 */
1024 msg_send_serial (out_msg_buf
);
1025 if (expect_msg (BKPT_SET_ACK
, in_msg_buf
, 1))
1027 return 0; /* Success */
1031 return 1; /* Failure */
1035 /************************************************* REMOTE_DELETE_BREAKPOINT */
1037 mm_remove_breakpoint (addr
, contents_cache
)
1039 char *contents_cache
;
1041 out_msg_buf
->bkpt_rm_msg
.code
= BKPT_RM
;
1042 out_msg_buf
->bkpt_rm_msg
.length
= 4 * 3;
1043 out_msg_buf
->bkpt_rm_msg
.memory_space
= I_MEM
;
1044 out_msg_buf
->bkpt_rm_msg
.bkpt_addr
= (ADDR32
) addr
;
1045 msg_send_serial (out_msg_buf
);
1046 if (expect_msg (BKPT_RM_ACK
, in_msg_buf
, 1))
1048 return 0; /* Success */
1052 return 1; /* Failure */
1057 /******************************************************* REMOTE_KILL */
1059 mm_kill (arg
, from_tty
)
1065 #if defined(KERNEL_DEBUGGING)
1066 /* We don't ever kill the kernel */
1069 printf ("Kernel not killed, but left in current state.\n");
1070 printf ("Use detach to leave kernel running.\n");
1073 out_msg_buf
->break_msg
.code
= BREAK
;
1074 out_msg_buf
->bkpt_set_msg
.length
= 4 * 0;
1075 expect_msg (HALT
, in_msg_buf
, from_tty
);
1078 printf ("Target has been stopped.");
1079 printf ("Would you like to do a hardware reset (y/n) [n] ");
1080 fgets (buf
, 3, stdin
);
1083 out_msg_buf
->reset_msg
.code
= RESET
;
1084 out_msg_buf
->bkpt_set_msg
.length
= 4 * 0;
1085 expect_msg (RESET_ACK
, in_msg_buf
, from_tty
);
1086 printf ("Target has been reset.");
1095 /***************************************************************************/
1097 * Load a program into the target.
1100 mm_load (arg_string
, from_tty
)
1106 #if defined(KERNEL_DEBUGGING)
1107 printf ("The kernel had better be loaded already! Loading not done.\n");
1109 if (arg_string
== 0)
1110 error ("The load command takes a file name");
1112 arg_string
= tilde_expand (arg_string
);
1113 make_cleanup (free
, arg_string
);
1116 error ("File loading is not yet supported for MiniMon.");
1117 /* FIXME, code to load your file here... */
1118 /* You may need to do an init_target_mm() */
1119 /* init_target_mm(?,?,?,?,?,?,?,?); */
1121 /* symbol_file_add (arg_string, from_tty, text_addr, 0, 0); */
1126 /************************************************ REMOTE_WRITE_INFERIOR_MEMORY
1127 ** Copy LEN bytes of data from debugger memory at MYADDR
1128 to inferior's memory at MEMADDR. Returns number of bytes written. */
1130 mm_write_inferior_memory (memaddr
, myaddr
, len
)
1137 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1138 out_msg_buf
->write_req_msg
.memory_space
= mm_memory_space (memaddr
);
1141 while (nwritten
< len
)
1143 int num_to_write
= len
- nwritten
;
1144 if (num_to_write
> MAXDATA
)
1145 num_to_write
= MAXDATA
;
1146 for (i
= 0; i
< num_to_write
; i
++)
1147 out_msg_buf
->write_req_msg
.data
[i
] = myaddr
[i
+ nwritten
];
1148 out_msg_buf
->write_req_msg
.byte_count
= num_to_write
;
1149 out_msg_buf
->write_req_msg
.length
= 3 * 4 + num_to_write
;
1150 out_msg_buf
->write_req_msg
.address
= memaddr
+ nwritten
;
1151 msg_send_serial (out_msg_buf
);
1153 if (expect_msg (WRITE_ACK
, in_msg_buf
, 1))
1155 nwritten
+= in_msg_buf
->write_ack_msg
.byte_count
;
1165 /************************************************* REMOTE_READ_INFERIOR_MEMORY
1166 ** Read LEN bytes from inferior memory at MEMADDR. Put the result
1167 at debugger address MYADDR. Returns number of bytes read. */
1169 mm_read_inferior_memory (memaddr
, myaddr
, len
)
1176 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1177 out_msg_buf
->read_req_msg
.memory_space
= mm_memory_space (memaddr
);
1182 int num_to_read
= (len
- nread
);
1183 if (num_to_read
> MAXDATA
)
1184 num_to_read
= MAXDATA
;
1185 out_msg_buf
->read_req_msg
.byte_count
= num_to_read
;
1186 out_msg_buf
->read_req_msg
.length
= 3 * 4 + num_to_read
;
1187 out_msg_buf
->read_req_msg
.address
= memaddr
+ nread
;
1188 msg_send_serial (out_msg_buf
);
1190 if (expect_msg (READ_ACK
, in_msg_buf
, 1))
1192 for (i
= 0; i
< in_msg_buf
->read_ack_msg
.byte_count
; i
++)
1193 myaddr
[i
+ nread
] = in_msg_buf
->read_ack_msg
.data
[i
];
1194 nread
+= in_msg_buf
->read_ack_msg
.byte_count
;
1204 /* FIXME! Merge these two. */
1206 mm_xfer_inferior_memory (memaddr
, myaddr
, len
, write
)
1213 memaddr
= translate_addr (memaddr
);
1216 return mm_write_inferior_memory (memaddr
, myaddr
, len
);
1218 return mm_read_inferior_memory (memaddr
, myaddr
, len
);
1222 /********************************************************** MSG_SEND_SERIAL
1223 ** This function is used to send a message over the
1226 ** If the message is successfully sent, a zero is
1227 ** returned. If the message was not sendable, a -1
1228 ** is returned. This function blocks. That is, it
1229 ** does not return until the message is completely
1230 ** sent, or until an error is encountered.
1235 msg_send_serial (msg_ptr
)
1236 union msg_t
*msg_ptr
;
1243 /* Send message header */
1245 message_size
= msg_ptr
->generic_msg
.length
+ (2 * sizeof (INT32
));
1248 c
= *((char *) msg_ptr
+ byte_count
);
1249 result
= write (mm_desc
, &c
, 1);
1252 byte_count
= byte_count
+ 1;
1255 while ((byte_count
< message_size
));
1258 } /* end msg_send_serial() */
1260 /********************************************************** MSG_RECV_SERIAL
1261 ** This function is used to receive a message over a
1264 ** If the message is waiting in the buffer, a zero is
1265 ** returned and the buffer pointed to by msg_ptr is filled
1266 ** in. If no message was available, a -1 is returned.
1267 ** If timeout==0, wait indefinetly for a character.
1272 msg_recv_serial (msg_ptr
)
1273 union msg_t
*msg_ptr
;
1275 static INT32 length
= 0;
1276 static INT32 byte_count
= 0;
1279 if (msg_ptr
== 0) /* re-sync request */
1284 /* The timeout here is the prevailing timeout set with VTIME */
1285 ->"timeout==0 semantics not supported"
1286 read (mm_desc
, in_buf
, BUFER_SIZE
);
1289 read (mm_desc
, in_buf
, BUFER_SIZE
);
1294 /* Receive message */
1296 /* Timeout==0, help support the mm_wait() routine */
1297 ->"timeout==0 semantics not supported (and its nice if they are)"
1298 result
= read (mm_desc
, &c
, 1);
1301 result
= read (mm_desc
, &c
, 1);
1308 error ("Timeout reading from remote system.");
1311 perror_with_name ("remote");
1313 else if (result
== 1)
1315 *((char *) msg_ptr
+ byte_count
) = c
;
1316 byte_count
= byte_count
+ 1;
1319 /* Message header received. Save message length. */
1320 if (byte_count
== (2 * sizeof (INT32
)))
1321 length
= msg_ptr
->generic_msg
.length
;
1323 if (byte_count
>= (length
+ (2 * sizeof (INT32
))))
1325 /* Message received */
1332 } /* end msg_recv_serial() */
1334 /********************************************************************* KBD_RAW
1335 ** This function is used to put the keyboard in "raw"
1336 ** mode for BSD Unix. The original status is saved
1337 ** so that it may be restored later.
1347 /* Get keyboard termio (to save to restore original modes) */
1349 result
= ioctl (0, TCGETA
, &kbd_tbuf
);
1351 result
= ioctl (0, TIOCGETP
, &kbd_tbuf
);
1356 /* Get keyboard TERMINAL (for modification) */
1358 result
= ioctl (0, TCGETA
, &tbuf
);
1360 result
= ioctl (0, TIOCGETP
, &tbuf
);
1365 /* Set up new parameters */
1367 tbuf
.c_iflag
= tbuf
.c_iflag
&
1368 ~(INLCR
| ICRNL
| IUCLC
| ISTRIP
| IXON
| BRKINT
);
1369 tbuf
.c_lflag
= tbuf
.c_lflag
& ~(ICANON
| ISIG
| ECHO
);
1370 tbuf
.c_cc
[4] = 0; /* MIN */
1371 tbuf
.c_cc
[5] = 0; /* TIME */
1373 /* FIXME: not sure if this is correct (matches HAVE_TERMIO). */
1374 tbuf
.sg_flags
|= RAW
;
1375 tbuf
.sg_flags
|= ANYP
;
1376 tbuf
.sg_flags
&= ~ECHO
;
1379 /* Set keyboard termio to new mode (RAW) */
1381 result
= ioctl (0, TCSETAF
, &tbuf
);
1383 result
= ioctl (0, TIOCSETP
, &tbuf
);
1389 } /* end kbd_raw() */
1393 /***************************************************************** KBD_RESTORE
1394 ** This function is used to put the keyboard back in the
1395 ** mode it was in before kbk_raw was called. Note that
1396 ** kbk_raw() must have been called at least once before
1397 ** kbd_restore() is called.
1405 /* Set keyboard termio to original mode */
1407 result
= ioctl (0, TCSETAF
, &kbd_tbuf
);
1409 result
= ioctl (0, TIOCGETP
, &kbd_tbuf
);
1416 } /* end kbd_cooked() */
1419 /*****************************************************************************/
1420 /* Fetch a single register indicatated by 'regno'.
1421 * Returns 0/-1 on success/failure.
1424 fetch_register (regno
)
1428 out_msg_buf
->read_req_msg
.code
= READ_REQ
;
1429 out_msg_buf
->read_req_msg
.length
= 4 * 3;
1430 out_msg_buf
->read_req_msg
.byte_count
= 4;
1432 if (regno
== GR1_REGNUM
)
1434 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1435 out_msg_buf
->read_req_msg
.address
= 1;
1437 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1439 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1440 out_msg_buf
->read_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1442 #if defined(GR64_REGNUM)
1443 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32)
1445 out_msg_buf
->read_req_msg
.memory_space
= GLOBAL_REG
;
1446 out_msg_buf
->read_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1448 #endif /* GR64_REGNUM */
1449 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1451 out_msg_buf
->read_req_msg
.memory_space
= LOCAL_REG
;
1452 out_msg_buf
->read_req_msg
.address
= (regno
- LR0_REGNUM
);
1454 else if (regno
>= FPE_REGNUM
&& regno
<= EXO_REGNUM
)
1457 supply_register (160 + (regno
- FPE_REGNUM
), &val
);
1458 return 0; /* Pretend Success */
1462 out_msg_buf
->read_req_msg
.memory_space
= SPECIAL_REG
;
1463 out_msg_buf
->read_req_msg
.address
= regnum_to_srnum (regno
);
1466 msg_send_serial (out_msg_buf
);
1468 if (expect_msg (READ_ACK
, in_msg_buf
, 1))
1470 supply_register (regno
, &(in_msg_buf
->read_r_ack_msg
.data
[0]));
1479 /*****************************************************************************/
1480 /* Store a single register indicated by 'regno'.
1481 * Returns 0/-1 on success/failure.
1484 store_register (regno
)
1489 out_msg_buf
->write_req_msg
.code
= WRITE_REQ
;
1490 out_msg_buf
->write_req_msg
.length
= 4 * 4;
1491 out_msg_buf
->write_req_msg
.byte_count
= 4;
1492 out_msg_buf
->write_r_msg
.data
[0] = read_register (regno
);
1494 if (regno
== GR1_REGNUM
)
1496 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1497 out_msg_buf
->write_req_msg
.address
= 1;
1498 /* Setting GR1 changes the numbers of all the locals, so invalidate the
1499 * register cache. Do this *after* calling read_register, because we want
1500 * read_register to return the value that write_register has just stuffed
1501 * into the registers array, not the value of the register fetched from
1504 registers_changed ();
1506 #if defined(GR64_REGNUM)
1507 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32)
1509 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1510 out_msg_buf
->write_req_msg
.address
= (regno
- GR64_REGNUM
) + 64;
1512 #endif /* GR64_REGNUM */
1513 else if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
1515 out_msg_buf
->write_req_msg
.memory_space
= GLOBAL_REG
;
1516 out_msg_buf
->write_req_msg
.address
= (regno
- GR96_REGNUM
) + 96;
1518 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
1520 out_msg_buf
->write_req_msg
.memory_space
= LOCAL_REG
;
1521 out_msg_buf
->write_req_msg
.address
= (regno
- LR0_REGNUM
);
1523 else if (regno
>= FPE_REGNUM
&& regno
<= EXO_REGNUM
)
1525 return 0; /* Pretend Success */
1528 /* An unprotected or protected special register */
1530 out_msg_buf
->write_req_msg
.memory_space
= SPECIAL_REG
;
1531 out_msg_buf
->write_req_msg
.address
= regnum_to_srnum (regno
);
1534 msg_send_serial (out_msg_buf
);
1536 if (expect_msg (WRITE_ACK
, in_msg_buf
, 1))
1546 /****************************************************************************/
1548 * Convert a gdb special register number to a 29000 special register number.
1551 regnum_to_srnum (regno
)
1577 return (USE_SHADOW_PC
? (20) : (10));
1579 return (USE_SHADOW_PC
? (21) : (11));
1581 return (USE_SHADOW_PC
? (22) : (12));
1611 return (255); /* Failure ? */
1614 /****************************************************************************/
1616 * Initialize the target debugger (minimon only).
1619 init_target_mm (tstart
, tend
, dstart
, dend
, entry
, ms_size
, rs_size
, arg_start
)
1620 ADDR32 tstart
, tend
, dstart
, dend
, entry
;
1621 INT32 ms_size
, rs_size
;
1624 out_msg_buf
->init_msg
.code
= INIT
;
1625 out_msg_buf
->init_msg
.length
= sizeof (struct init_msg_t
) - 2 * sizeof (INT32
);
1626 out_msg_buf
->init_msg
.text_start
= tstart
;
1627 out_msg_buf
->init_msg
.text_end
= tend
;
1628 out_msg_buf
->init_msg
.data_start
= dstart
;
1629 out_msg_buf
->init_msg
.data_end
= dend
;
1630 out_msg_buf
->init_msg
.entry_point
= entry
;
1631 out_msg_buf
->init_msg
.mem_stack_size
= ms_size
;
1632 out_msg_buf
->init_msg
.reg_stack_size
= rs_size
;
1633 out_msg_buf
->init_msg
.arg_start
= arg_start
;
1634 msg_send_serial (out_msg_buf
);
1635 expect_msg (INIT_ACK
, in_msg_buf
, 1);
1637 /****************************************************************************/
1639 * Return a pointer to a string representing the given message code.
1640 * Not all messages are represented here, only the ones that we expect
1641 * to be called with.
1647 static char cbuf
[32];
1652 sprintf (cbuf
, "%s (%d)", "BKPT_SET_ACK", code
);
1655 sprintf (cbuf
, "%s (%d)", "BKPT_RM_ACK", code
);
1658 sprintf (cbuf
, "%s (%d)", "INIT_ACK", code
);
1661 sprintf (cbuf
, "%s (%d)", "READ_ACK", code
);
1664 sprintf (cbuf
, "%s (%d)", "WRITE_ACK", code
);
1667 sprintf (cbuf
, "%s (%d)", "ERROR", code
);
1670 sprintf (cbuf
, "%s (%d)", "HALT", code
);
1673 sprintf (cbuf
, "UNKNOWN (%d)", code
);
1678 /****************************************************************************/
1680 * Selected (not all of them) error codes that we might get.
1683 error_msg_str (code
)
1686 static char cbuf
[50];
1691 return ("EMFAIL: unrecoverable error");
1693 return ("EMBADADDR: Illegal address");
1695 return ("EMBADREG: Illegal register ");
1697 return ("EMACCESS: Could not access memory");
1699 return ("EMBADMSG: Unknown message type");
1701 return ("EMMSG2BIG: Message to large");
1703 return ("EMNOSEND: Could not send message");
1705 return ("EMNORECV: Could not recv message");
1707 return ("EMRESET: Could not RESET target");
1709 return ("EMCONFIG: Could not get target CONFIG");
1711 return ("EMSTATUS: Could not get target STATUS");
1713 return ("EMREAD: Could not READ target memory");
1715 return ("EMWRITE: Could not WRITE target memory");
1717 return ("EMBKPTSET: Could not set breakpoint");
1719 return ("EMBKPTRM: Could not remove breakpoint");
1721 return ("EMBKPTSTAT: Could not get breakpoint status");
1723 return ("EMBKPTNONE: All breakpoints in use");
1725 return ("EMBKPTUSED: Breakpoints already in use");
1727 return ("EMINIT: Could not init target memory");
1729 return ("EMGO: Could not start execution");
1731 return ("EMSTEP: Could not single step");
1733 return ("EMBREAK: Could not BREAK");
1735 return ("EMCOMMERR: Communication error");
1737 sprintf (cbuf
, "error number %d", code
);
1743 /****************************************************************************/
1745 * Receive a message and expect it to be of type msgcode.
1746 * Returns 0/1 on failure/success.
1749 expect_msg (msgcode
, msg_buf
, from_tty
)
1750 INT32 msgcode
; /* Msg code we expect */
1751 union msg_t
*msg_buf
; /* Where to put the message received */
1752 int from_tty
; /* Print message on error if non-zero */
1755 while (msg_recv_serial (msg_buf
) && (retries
++ < MAX_RETRIES
));
1756 if (retries
>= MAX_RETRIES
)
1758 printf ("Expected msg %s, ", msg_str (msgcode
));
1759 printf ("no message received!\n");
1760 return (0); /* Failure */
1763 if (msg_buf
->generic_msg
.code
!= msgcode
)
1767 printf ("Expected msg %s, ", msg_str (msgcode
));
1768 printf ("got msg %s\n", msg_str (msg_buf
->generic_msg
.code
));
1769 if (msg_buf
->generic_msg
.code
== ERROR
)
1770 printf ("%s\n", error_msg_str (msg_buf
->error_msg
.error_code
));
1772 return (0); /* Failure */
1774 return (1); /* Success */
1776 /****************************************************************************/
1778 * Determine the MiniMon memory space qualifier based on the addr.
1779 * FIXME: Can't distinguis I_ROM/D_ROM.
1780 * FIXME: Doesn't know anything about I_CACHE/D_CACHE.
1783 mm_memory_space (addr
)
1786 ADDR32 tstart
= target_config
.I_mem_start
;
1787 ADDR32 tend
= tstart
+ target_config
.I_mem_size
;
1788 ADDR32 dstart
= target_config
.D_mem_start
;
1789 ADDR32 dend
= tstart
+ target_config
.D_mem_size
;
1790 ADDR32 rstart
= target_config
.ROM_start
;
1791 ADDR32 rend
= tstart
+ target_config
.ROM_size
;
1793 if (((ADDR32
) addr
>= tstart
) && ((ADDR32
) addr
< tend
))
1797 else if (((ADDR32
) addr
>= dstart
) && ((ADDR32
) addr
< dend
))
1801 else if (((ADDR32
) addr
>= rstart
) && ((ADDR32
) addr
< rend
))
1803 /* FIXME: how do we determine between D_ROM and I_ROM */
1806 else /* FIXME: what do me do now? */
1807 return D_MEM
; /* Hmmm! */
1810 /****************************************************************************/
1812 * Define the target subroutine names
1814 struct target_ops mm_ops
;
1819 mm_ops
.to_shortname
= "minimon";
1820 mm_ops
.to_longname
= "Remote AMD/Minimon target";
1821 mm_ops
.to_doc
= "Remote debug an AMD 290*0 using the MiniMon dbg core on the target";
1822 mm_ops
.to_open
= mm_open
;
1823 mm_ops
.to_close
= mm_close
;
1824 mm_ops
.to_attach
= mm_attach
;
1825 mm_ops
.to_post_attach
= NULL
;
1826 mm_ops
.to_require_attach
= NULL
;
1827 mm_ops
.to_detach
= mm_detach
;
1828 mm_ops
.to_require_detach
= NULL
;
1829 mm_ops
.to_resume
= mm_resume
;
1830 mm_ops
.to_wait
= mm_wait
;
1831 mm_ops
.to_post_wait
= NULL
;
1832 mm_ops
.to_fetch_registers
= mm_fetch_registers
;
1833 mm_ops
.to_store_registers
= mm_store_registers
;
1834 mm_ops
.to_prepare_to_store
= mm_prepare_to_store
;
1835 mm_ops
.to_xfer_memory
= mm_xfer_inferior_memory
;
1836 mm_ops
.to_files_info
= mm_files_info
;
1837 mm_ops
.to_insert_breakpoint
= mm_insert_breakpoint
;
1838 mm_ops
.to_remove_breakpoint
= mm_remove_breakpoint
;
1839 mm_ops
.to_terminal_init
= 0;
1840 mm_ops
.to_terminal_inferior
= 0;
1841 mm_ops
.to_terminal_ours_for_output
= 0;
1842 mm_ops
.to_terminal_ours
= 0;
1843 mm_ops
.to_terminal_info
= 0;
1844 mm_ops
.to_kill
= mm_kill
;
1845 mm_ops
.to_load
= mm_load
;
1846 mm_ops
.to_lookup_symbol
= 0;
1847 mm_ops
.to_create_inferior
= mm_create_inferior
;
1848 mm_ops
.to_post_startup_inferior
= NULL
;
1849 mm_ops
.to_acknowledge_created_inferior
= NULL
;
1850 mm_ops
.to_clone_and_follow_inferior
= NULL
;
1851 mm_ops
.to_post_follow_inferior_by_clone
= NULL
;
1852 mm_ops
.to_insert_fork_catchpoint
= NULL
;
1853 mm_ops
.to_remove_fork_catchpoint
= NULL
;
1854 mm_ops
.to_insert_vfork_catchpoint
= NULL
;
1855 mm_ops
.to_remove_vfork_catchpoint
= NULL
;
1856 mm_ops
.to_has_forked
= NULL
;
1857 mm_ops
.to_has_vforked
= NULL
;
1858 mm_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
1859 mm_ops
.to_post_follow_vfork
= NULL
;
1860 mm_ops
.to_insert_exec_catchpoint
= NULL
;
1861 mm_ops
.to_remove_exec_catchpoint
= NULL
;
1862 mm_ops
.to_has_execd
= NULL
;
1863 mm_ops
.to_reported_exec_events_per_exec_call
= NULL
;
1864 mm_ops
.to_has_exited
= NULL
;
1865 mm_ops
.to_mourn_inferior
= mm_mourn
;
1866 mm_ops
.to_can_run
= 0;
1867 mm_ops
.to_notice_signals
= 0;
1868 mm_ops
.to_thread_alive
= 0;
1870 mm_ops
.to_pid_to_exec_file
= NULL
;
1871 mm_ops
.to_core_file_to_sym_file
= NULL
;
1872 mm_ops
.to_stratum
= process_stratum
;
1873 mm_ops
.DONT_USE
= 0;
1874 mm_ops
.to_has_all_memory
= 1;
1875 mm_ops
.to_has_memory
= 1;
1876 mm_ops
.to_has_stack
= 1;
1877 mm_ops
.to_has_registers
= 1;
1878 mm_ops
.to_has_execution
= 1;
1879 mm_ops
.to_sections
= 0;
1880 mm_ops
.to_sections_end
= 0;
1881 mm_ops
.to_magic
= OPS_MAGIC
;
1885 _initialize_remote_mm ()
1888 add_target (&mm_ops
);
1891 #ifdef NO_HIF_SUPPORT
1895 return (0); /* Emulate a failure */