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