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