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