projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* Check in Fred Fish's changes in these modules. Fred
[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
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
60extern int stop_soon_quietly; /* for wait_for_inferior */
61
7c18a68f
JG		 62static void mm_resume();
63static void mm_fetch_registers ();
64static int fetch_register ();
65static int mm_store_registers ();
66static int store_register ();
67static int regnum_to_srnum();
68static void mm_close ();
69static char* msg_str();
70static char* error_msg_str();
71static int expect_msg();
72static void init_target_mm();
73static 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
82static char *processor_name[] = { "Unknown", "A29000", "A29030", "A29050" };
83static 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)
89FILE *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
111static char out_buf[BUFER_SIZE];
112static char in_buf[BUFER_SIZE];
113
114int msg_recv_serial();
115int msg_send_serial();
116
117#define MAX_RETRIES 5000
118extern struct target_ops mm_ops; /* Forward declaration */
119struct config_msg_t target_config; /* HIF needs this */
120union msg_t *out_msg_buf = (union msg_t*)out_buf;
121union msg_t *in_msg_buf = (union msg_t*)in_buf;
122
123static 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. */
128int mm_desc = -1;
129
130/* stream which is fdopen'd from mm_desc. Only valid when
131 mm_desc != -1. */
132FILE *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
142volatile int n_alarms;
143
144static void
145mm_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. */
156static 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. */
166static void
167mm_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\
197Assuming 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 */
213static void
214mm_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
234static 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
254static 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
272static char *dev_name;
273int baudrate = 9600;
274static void
275mm_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;
e36ca74a 288 p && *p && !isspace (*p); p++)
7c18a68f 289 ;
e36ca74a 290 if (p == 0 || *p == '\0')
7c18a68f
JG		 291erroid:
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. */
443static void
444mm_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 */
483static void
484mm_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). */
528static void
529mm_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
546static void
547mm_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
573static int
574mm_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 }
630halted:
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
687exit:
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 */
700static void
701mm_fetch_registers (regno)
702int 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
15f27b29 807 * Store register regno into the target.
7c18a68f 808 * If regno==-1 then store all the registers.
15f27b29 809 * Result is 0 for success, -1 for failure.
7c18a68f
JG		 810 */
811
812static int
813mm_store_registers (regno)
814int regno;
815{
15f27b29 816 int result;
7c18a68f
JG		 817
818 if (regno >= 0)
819 return(store_register(regno));
820
821 DENTER("mm_store_registers()");
15f27b29 822 result = 0;
7c18a68f
JG		 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);
15f27b29
JG		 834 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
835 result = -1;
836 }
7c18a68f
JG		 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);
15f27b29
JG		 849 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
850 result = -1;
851 }
7c18a68f
JG		 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);
15f27b29
JG		 863 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
864 result = -1;
865 }
7c18a68f
JG		 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);
15f27b29
JG		 878 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
879 result = -1;
880 }
7c18a68f
JG		 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);
15f27b29
JG		 891 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
892 result = -1;
893 }
7c18a68f
JG		 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);
15f27b29
JG		 905 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
906 result = -1;
907 }
7c18a68f
JG		 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);
15f27b29
JG		 916 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
917 result = -1;
918 }
7c18a68f
JG		 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);
15f27b29
JG		 927 if (!expect_msg(WRITE_ACK,in_msg_buf,1)) {
928 result = -1;
929 }
7c18a68f
JG		 930
931 registers_changed ();
932 DEXIT("mm_store_registers()");
15f27b29 933 return result;
7c18a68f
JG		 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
943static void
944mm_prepare_to_store ()
945{
946 /* Do nothing, since we can store individual regs */
947}
948
949/******************************************************* REMOTE_XFER_MEMORY */
950static CORE_ADDR
951translate_addr(addr)
952CORE_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}
7c18a68f
JG		 969
970/******************************************************* REMOTE_FILES_INFO */
971static void
972mm_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 */
979static int
980mm_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 */
1002static int
1003mm_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 */
1024static void
1025mm_kill(arg,from_tty)
1026char *arg;
1027int 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 */
1064static void
1065mm_load(arg_string,from_tty)
1066char *arg_string;
1067int 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--;
1ab3bf1b 1086 /* (void) symbol_file_add (arg_string, from_tty, text_addr, 0); */
7c18a68f
JG		 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. */
1094static int
1095mm_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. */
1130static int
1131mm_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
15f27b29
JG		 1162/* FIXME! Merge these two. */
1163static int
1164mm_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
7c18a68f
JG		 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
1192int
1193msg_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
1226int
1227msg_recv_serial(msg_ptr)
1228union 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*/
1286TERMINAL kbd_tbuf;
1287
1288int
1289kbd_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
1346int
1347kbd_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 */
1368static int
1369fetch_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 */
1421static int
1422store_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 */
1481static int
1482regnum_to_srnum(regno)
1483int 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 */
1521static void
1522init_target_mm(tstart,tend,dstart,dend,entry,ms_size,rs_size,arg_start)
1523ADDR32 tstart,tend,dstart,dend,entry;
1524INT32 ms_size,rs_size;
1525ADDR32 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 */
1546static char*
1547msg_str(code)
1548INT32 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 */
1568static char*
1569error_msg_str(code)
1570INT32 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 */
1608static int
1609expect_msg(msgcode,msg_buf,from_tty)
1610INT32 msgcode; /* Msg code we expect */
1611union msg_t *msg_buf; /* Where to put the message received */
1612int 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 */
1643static int
1644mm_memory_space(addr)
1645CORE_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 */
1669struct 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,
7c18a68f
JG		 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
1691void
1692_initialize_remote_mm()
1693{
1694 add_target (&mm_ops);
1695}
1696
1697#ifdef NO_HIF_SUPPORT
1698service_HIF(msg)
1699union msg_t *msg;
1700{
1701 return(0); /* Emulate a failure */
1702}
1703#endif
GDB Binutils - Deliverables
This page took 0.108921 seconds and 4 git commands to generate.