1 /* Remote debugging interface for AMD 290*0 Adapt Monitor Version 2.1d18.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by David Wood at New York University (wood@lab.ultra.nyu.edu).
4 Adapted from work done at Cygnus Support in remote-eb.c.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
22 /* This is like remote.c but is for an esoteric situation--
23 having a 29k board attached to an Adapt inline monitor.
24 The monitor is connected via serial line to a unix machine
27 3/91 - developed on Sun3 OS 4.1, by David Wood
28 o - I can't get binary coff to load.
29 o - I can't get 19200 baud rate to work.
30 7/91 o - Freeze mode tracing can be done on a 29050. */
46 /* External data declarations */
47 extern int stop_soon_quietly
; /* for wait_for_inferior */
49 /* Forward data declarations */
50 extern struct target_ops adapt_ops
; /* Forward declaration */
52 /* Forward function declarations */
53 static void adapt_fetch_registers ();
54 static int adapt_store_registers ();
55 static void adapt_close ();
56 static int adapt_clear_breakpoints();
59 * Processor types. It is assumed that the adapt has the correct
60 * ROM for the given processor.
62 #define TYPE_UNKNOWN 0
66 static char *processor_name
[] = { "Unknown", "A29000", "A29030", "A29050" };
67 static int processor_type
=TYPE_UNKNOWN
;
69 #define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
70 #define USE_SHADOW_PC ((processor_type == TYPE_A29050) && FREEZE_MODE)
73 /* #define DEBUG /* */
75 # define DENTER(NAME) (printf_filtered("Entering %s\n",NAME), fflush(stdout))
76 # define DEXIT(NAME) (printf_filtered("Exiting %s\n",NAME), fflush(stdout))
82 /* Can't seem to get binary coff working */
83 #define ASCII_COFF /* Adapt will be downloaded with ascii coff */
85 #define LOG_FILE "adapt.log"
86 #if defined (LOG_FILE)
90 static int timeout
= 5;
91 static char *dev_name
;
93 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
94 adapt_open knows that we don't have a file open when the program
98 /* stream which is fdopen'd from adapt_desc. Only valid when
105 rawmode(desc
, turnon
)
114 ioctl (desc
, TIOCGETP
, &sg
);
118 sg
.c_lflag
&= ~(ICANON
);
124 sg
.c_lflag
|= ICANON
;
126 sg
.sg_flags
&= ~(RAW
);
129 ioctl (desc
, TIOCSETP
, &sg
);
132 /* Suck up all the input from the adapt */
138 /* termio does the timeout for us. */
139 while (read (adapt_desc
, buf
, 8) > 0);
142 while (read (adapt_desc
, buf
, 8) > 0);
147 /* Read a character from the remote system, doing all the fancy
156 /* termio does the timeout for us. */
157 read (adapt_desc
, &buf
, 1);
160 if (read (adapt_desc
, &buf
, 1) < 0)
163 error ("Timeout reading from remote system.");
165 perror_with_name ("remote");
171 error ("Timeout reading from remote system.");
172 #if defined (LOG_FILE)
173 putc (buf
& 0x7f, log_file
);
178 /* Keep discarding input from the remote system, until STRING is found.
179 Let the user break out immediately. */
186 fflush(adapt_stream
);
190 if (readchar() == *p
)
204 /* Keep discarding input until we see the adapt prompt.
206 The convention for dealing with the prompt is that you
208 o *then* wait for the prompt.
210 Thus the last thing that a procedure does with the serial line
211 will be an expect_prompt(). Exception: adapt_resume does not
212 wait for the prompt, because the terminal is being handed over
213 to the inferior. However, the next thing which happens after that
214 is a adapt_wait which does wait for the prompt.
215 Note that this includes abnormal exit, e.g. error(). This is
216 necessary to prevent getting into states from which we can't
221 #if defined (LOG_FILE)
222 /* This is a convenient place to do this. The idea is to do it often
223 enough that we never lose much data if we terminate abnormally. */
226 fflush(adapt_stream
);
230 /* Get a hex digit from the remote system & return its value.
231 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
233 get_hex_digit (ignore_space
)
240 if (ch
>= '0' && ch
<= '9')
242 else if (ch
>= 'A' && ch
<= 'F')
243 return ch
- 'A' + 10;
244 else if (ch
>= 'a' && ch
<= 'f')
245 return ch
- 'a' + 10;
246 else if (ch
== ' ' && ignore_space
)
251 error ("Invalid hex digit from remote system.");
256 /* Get a byte from adapt_desc and put it in *BYT. Accept any number
264 val
= get_hex_digit (1) << 4;
265 val
|= get_hex_digit (0);
269 /* Read a 32-bit hex word from the adapt, preceded by a space */
277 for (j
= 0; j
< 8; j
++)
278 val
= (val
<< 4) + get_hex_digit (j
== 0);
281 /* Get N 32-bit hex words from remote, each preceded by a space
282 and put them in registers starting at REGNO. */
284 get_hex_regs (n
, regno
)
290 val
= get_hex_word();
291 supply_register(regno
++,&val
);
294 /* Called when SIGALRM signal sent due to alarm() timeout. */
299 # define volatile /**/
302 volatile int n_alarms
;
309 printf ("adapt_timer called\n");
315 /* malloc'd name of the program on the remote system. */
316 static char *prog_name
= NULL
;
318 /* Number of SIGTRAPs we need to simulate. That is, the next
319 NEED_ARTIFICIAL_TRAP calls to adapt_wait should just return
320 SIGTRAP without actually waiting for anything. */
322 static int need_artificial_trap
= 0;
325 adapt_kill(arg
,from_tty
)
329 DENTER("adapt_kill()");
330 fprintf (adapt_stream
, "K");
331 fprintf (adapt_stream
, "\r");
333 DEXIT("adapt_kill()");
336 * Download a file specified in 'args', to the adapt.
337 * FIXME: Assumes the file to download is a binary coff file.
340 adapt_load(args
,fromtty
)
348 DENTER("adapt_load()");
350 printf_filtered("Adapt not open. Use 'target' command to open adapt\n");
354 /* OK, now read in the file. Y=read, C=COFF, T=dTe port
357 #ifdef ASCII_COFF /* Ascii coff */
358 fprintf (adapt_stream
, "YA T,0\r");
359 fflush(adapt_stream
); /* Just in case */
360 /* FIXME: should check args for only 1 argument */
361 sprintf(buffer
,"cat %s | btoa > /tmp/#adapt-btoa",args
);
363 fp
= fopen("/tmp/#adapt-btoa","r");
364 rawmode(adapt_desc
,OFF
);
365 while (n
=fread(buffer
,1,1024,fp
)) {
366 do { n
-= write(adapt_desc
,buffer
,n
); } while (n
>0);
367 if (n
<0) { perror("writing ascii coff"); break; }
370 rawmode(adapt_desc
,ON
);
371 system("rm /tmp/#adapt-btoa");
372 #else /* Binary coff - can't get it to work .*/
373 fprintf (adapt_stream
, "YC T,0\r");
374 fflush(adapt_stream
); /* Just in case */
375 if (!(fp
= fopen(args
,"r"))) {
376 printf_filtered("Can't open %s\n",args
);
379 while (n
=fread(buffer
,1,512,fp
)) {
380 do { n
-= write(adapt_desc
,buffer
,n
); } while (n
>0);
381 if (n
<0) { perror("writing ascii coff"); break; }
385 expect_prompt (); /* Skip garbage that comes out */
386 fprintf (adapt_stream
, "\r");
388 DEXIT("adapt_load()");
391 /* This is called not only when we first attach, but also when the
392 user types "run" after having attached. */
394 adapt_create_inferior (execfile
, args
, env
)
401 DENTER("adapt_create_inferior()");
404 error ("Can't pass arguments to remote adapt process.");
406 if (execfile
== 0 || exec_bfd
== 0)
407 error ("No exec file specified");
409 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
412 adapt_kill(NULL
,NULL
);
413 adapt_clear_breakpoints();
414 init_wait_for_inferior ();
415 /* Clear the input because what the adapt sends back is different
416 * depending on whether it was running or not.
418 slurp_input(); /* After this there should be a prompt */
419 fprintf(adapt_stream
,"\r");
421 printf_filtered("Do you want to download '%s' (y/n)? [y] : ",prog_name
);
425 if (*buffer
!= 'n') {
426 adapt_load(prog_name
,0);
431 /* Set the PC and wait for a go/cont */
432 fprintf (adapt_stream
, "G %x,N\r",entry_pt
);
433 printf_filtered("Now use the 'continue' command to start.\n");
436 insert_breakpoints (); /* Needed to get correct instruction in cache */
437 proceed(entry_pt
, -1, 0);
441 printf_filtered("Adapt not open yet.\n");
443 DEXIT("adapt_create_inferior()");
446 /* Translate baud rates from integers to damn B_codes. Unix should
447 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
456 static struct {int rate
, damn_b
;} baudtab
[] = {
476 static int damn_b (rate
)
481 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
482 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
483 return B38400
; /* Random */
487 /* Open a connection to a remote debugger.
488 NAME is the filename used for communication, then a space,
492 static int baudrate
= 9600;
494 adapt_open (name
, from_tty
)
502 DENTER("adapt_open()");
503 /* Find the first whitespace character, it separates dev_name from
509 *p
!= '\0' && !isspace (*p
); p
++)
514 Please include the name of the device for the serial port,\n\
515 the baud rate, and the name of the program to run on the remote system.");
516 dev_name
= (char*)malloc(p
- name
+ 1);
517 strncpy (dev_name
, name
, p
- name
);
518 dev_name
[p
- name
] = '\0';
520 /* Skip over the whitespace after dev_name */
521 for (; isspace (*p
); p
++)
524 if (1 != sscanf (p
, "%d ", &baudrate
))
527 /* Skip the number and then the spaces */
528 for (; isdigit (*p
); p
++)
530 for (; isspace (*p
); p
++)
533 if (prog_name
!= NULL
)
535 prog_name
= savestring (p
, strlen (p
));
539 adapt_desc
= open (dev_name
, O_RDWR
);
541 perror_with_name (dev_name
);
542 ioctl (adapt_desc
, TIOCGETP
, &sg
);
544 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
545 sg
.c_cc
[VTIME
] = timeout
* 10;
546 sg
.c_lflag
&= ~(ICANON
| ECHO
);
547 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
549 sg
.sg_ispeed
= damn_b (baudrate
);
550 sg
.sg_ospeed
= damn_b (baudrate
);
551 sg
.sg_flags
|= RAW
| ANYP
;
552 sg
.sg_flags
&= ~ECHO
;
555 ioctl (adapt_desc
, TIOCSETP
, &sg
);
556 adapt_stream
= fdopen (adapt_desc
, "r+");
558 push_target (&adapt_ops
);
559 /* start_remote (); /* Initialize gdb process mechanisms */
563 #ifndef NO_SIGINTERRUPT
564 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
566 if (siginterrupt (SIGALRM
, 1) != 0)
567 perror ("adapt_open: error in siginterrupt");
570 /* Set up read timeout timer. */
571 if ((void (*)) signal (SIGALRM
, adapt_timer
) == (void (*)) -1)
572 perror ("adapt_open: error in signal");
575 #if defined (LOG_FILE)
576 log_file
= fopen (LOG_FILE
, "w");
577 if (log_file
== NULL
)
578 perror_with_name (LOG_FILE
);
581 /* Put this port into NORMAL mode, send the 'normal' character */
582 write(adapt_desc
, "\ 1", 1); /* Control A */
583 write(adapt_desc
, "\r", 1);
586 /* Hello? Are you there? */
587 write (adapt_desc
, "\r", 1);
591 /* Clear any break points */
592 adapt_clear_breakpoints();
594 /* Determine the processor revision level */
595 prl
= (unsigned int)read_register(CFG_REGNUM
) >> 24;
597 processor_type
= TYPE_A29000
;
598 } else if ((prl
&0xf0) == 0x40) { /* 29030 = 0x4* */
599 processor_type
= TYPE_A29030
;
600 fprintf_filtered(stderr
,"WARNING: debugging of A29030 not tested.\n");
601 } else if ((prl
&0xf0) == 0x20) { /* 29050 = 0x2* */
602 processor_type
= TYPE_A29050
;
603 fprintf_filtered(stderr
,"WARNING: debugging of A29050 not tested.\n");
605 processor_type
= TYPE_UNKNOWN
;
606 fprintf_filtered(stderr
,"WARNING: processor type unknown.\n");
609 /* Print out some stuff, letting the user now what's going on */
610 printf_filtered("Remote debugging on an %s connect to an Adapt via %s.\n",
611 processor_name
[processor_type
],dev_name
);
612 /* FIXME: can this restriction be removed? */
613 printf_filtered("Remote debugging using virtual addresses works only\n");
614 printf_filtered("\twhen virtual addresses map 1:1 to physical addresses.\n");
615 if (processor_type
!= TYPE_A29050
) {
616 fprintf_filtered(stderr
,
617 "Freeze-mode debugging not available, and can only be done on an A29050.\n");
619 DEXIT("adapt_open()");
622 /* Close out all files and local state before this target loses control. */
625 adapt_close (quitting
)
629 DENTER("adapt_close()");
631 /* Clear any break points */
632 adapt_clear_breakpoints();
634 /* Put this port back into REMOTE mode */
636 fflush(adapt_stream
);
637 sleep(1); /* Let any output make it all the way back */
638 write(adapt_desc
, "R\r", 2);
641 /* Due to a bug in Unix, fclose closes not only the stdio stream,
642 but also the file descriptor. So we don't actually close
645 fclose (adapt_stream
); /* This also closes adapt_desc */
647 /* close (adapt_desc); */
649 /* Do not try to close adapt_desc again, later in the program. */
653 #if defined (LOG_FILE)
655 if (ferror (log_file
))
656 printf_filtered ("Error writing log file.\n");
657 if (fclose (log_file
) != 0)
658 printf_filtered ("Error closing log file.\n");
662 DEXIT("adapt_close()");
665 /* Attach to the target that is already loaded and possibly running */
667 adapt_attach (args
, from_tty
)
672 DENTER("adapt_attach()");
674 printf_filtered ("Attaching to remote program %s.\n", prog_name
);
676 /* push_target(&adapt_ops); /* This done in adapt_open() */
678 mark_breakpoints_out ();
680 /* Send the adapt a kill. It is ok if it is not already running */
681 fprintf(adapt_stream
, "K\r"); fflush(adapt_stream
);
682 expect_prompt(); /* Slurp the echo */
684 /* We will get a task spawn event immediately. */
685 init_wait_for_inferior ();
686 clear_proceed_status ();
687 stop_soon_quietly
= 1;
688 wait_for_inferior ();
689 stop_soon_quietly
= 0;
691 DEXIT("adapt_attach()");
695 /* Terminate the open connection to the remote debugger.
696 Use this when you want to detach and do something else
699 adapt_detach (args
,from_tty
)
703 DENTER("adapt_detach()");
704 if (adapt_stream
) { /* Send it on its way (tell it to continue) */
705 adapt_clear_breakpoints();
706 fprintf(adapt_stream
,"G\r");
709 pop_target(); /* calls adapt_close to do the real work */
711 printf_filtered ("Ending remote %s debugging\n", target_shortname
);
712 DEXIT("adapt_detach()");
715 /* Tell the remote machine to resume. */
718 adapt_resume (step
, sig
)
721 DENTER("adapt_resume()");
724 write (adapt_desc
, "t 1,s\r", 6);
725 /* Wait for the echo. */
726 expect ("t 1,s\r\n");
727 /* Then comes a line containing the instruction we stepped to. */
729 /* Then we get the prompt. */
732 /* Force the next adapt_wait to return a trap. Not doing anything
733 about I/O from the target means that the user has to type
734 "continue" to see any. FIXME, this should be fixed. */
735 need_artificial_trap
= 1;
739 write (adapt_desc
, "G\r", 2);
740 /* Swallow the echo. */
743 DEXIT("adapt_resume()");
746 /* Wait until the remote machine stops, then return,
747 storing status in STATUS just as `wait' would. */
753 /* Strings to look for. '?' means match any single character.
754 Note that with the algorithm we use, the initial character
755 of the string cannot recur in the string, or we will not
756 find some cases of the string in the input. */
758 static char bpt
[] = "@";
759 /* It would be tempting to look for "\n[__exit + 0x8]\n"
760 but that requires loading symbols with "yc i" and even if
761 we did do that we don't know that the file has symbols. */
762 static char exitmsg
[] = "@????????I JMPTI GR121,LR0";
766 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
768 /* Current position in swallowed. */
769 char *swallowed_p
= swallowed
;
773 int old_timeout
= timeout
;
774 int old_immediate_quit
= immediate_quit
;
776 DENTER("adapt_wait()");
778 WSETEXIT ((*status
), 0);
780 if (need_artificial_trap
!= 0)
782 WSETSTOP ((*status
), SIGTRAP
);
783 need_artificial_trap
--;
787 timeout
= 0; /* Don't time out -- user program is running. */
788 immediate_quit
= 1; /* Helps ability to QUIT */
790 QUIT
; /* Let user quit and leave process running */
802 if (ch
== *ep
|| *ep
== '?') {
814 /* Print out any characters which have been swallowed. */
815 for (p
= swallowed
; p
< swallowed_p
; ++p
)
817 swallowed_p
= swallowed
;
823 WSETSTOP ((*status
), SIGTRAP
);
825 WSETEXIT ((*status
), 0);
826 timeout
= old_timeout
;
827 immediate_quit
= old_immediate_quit
;
828 DEXIT("adapt_wait()");
832 /* Return the name of register number REGNO
833 in the form input and output by adapt.
835 Returns a pointer to a static buffer containing the answer. */
841 if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32 )
842 sprintf (buf
, "GR%03d", regno
- GR96_REGNUM
+ 96);
843 #if defined(GR64_REGNUM)
844 else if (regno
>= GR64_REGNUM
&& regno
< GR64_REGNUM
+ 32 )
845 sprintf (buf
, "GR%03d", regno
- GR64_REGNUM
+ 64);
847 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
848 sprintf (buf
, "LR%03d", regno
- LR0_REGNUM
);
849 else if (regno
== Q_REGNUM
)
850 strcpy (buf
, "SR131");
851 else if (regno
>= BP_REGNUM
&& regno
<= CR_REGNUM
)
852 sprintf (buf
, "SR%03d", regno
- BP_REGNUM
+ 133);
853 else if (regno
== ALU_REGNUM
)
854 strcpy (buf
, "SR132");
855 else if (regno
>= IPC_REGNUM
&& regno
<= IPB_REGNUM
)
856 sprintf (buf
, "SR%03d", regno
- IPC_REGNUM
+ 128);
857 else if (regno
>= VAB_REGNUM
&& regno
<= LRU_REGNUM
) {
858 /* When a 29050 is in freeze-mode, read shadow pcs instead */
859 if ((regno
>= NPC_REGNUM
&& regno
<= PC2_REGNUM
) && USE_SHADOW_PC
)
860 sprintf (buf
, "SR%03d", regno
- NPC_REGNUM
+ 20);
862 sprintf (buf
, "SR%03d", regno
- VAB_REGNUM
);
864 else if (regno
== GR1_REGNUM
)
865 strcpy (buf
, "GR001");
869 /* Read the remote registers. */
872 adapt_fetch_registers ()
880 DENTER("adapt_fetch_registers()");
885 #if defined(GR64_REGNUM)
886 write (adapt_desc
, "dw gr64,gr95\r", 13);
887 for (reg_index
= 64, regnum_index
= GR64_REGNUM
;
889 reg_index
+= 4, regnum_index
+= 4)
891 sprintf (tempbuf
, "GR%03d ", reg_index
);
893 get_hex_regs (4, regnum_index
);
897 write (adapt_desc
, "dw gr96,gr127\r", 14);
898 for (reg_index
= 96, regnum_index
= GR96_REGNUM
;
900 reg_index
+= 4, regnum_index
+= 4)
902 sprintf (tempbuf
, "GR%03d ", reg_index
);
904 get_hex_regs (4, regnum_index
);
911 for (i
= 0; i
< 128; i
+= 32)
913 /* The PC has a tendency to hang if we get these
914 all in one fell swoop ("dw lr0,lr127"). */
915 sprintf (tempbuf
, "dw lr%d\r", i
);
916 write (adapt_desc
, tempbuf
, strlen (tempbuf
));
917 for (reg_index
= i
, regnum_index
= LR0_REGNUM
+ i
;
919 reg_index
+= 4, regnum_index
+= 4)
921 sprintf (tempbuf
, "LR%03d ", reg_index
);
923 get_hex_regs (4, regnum_index
);
931 sprintf (tempbuf
, "dw sr0\r");
932 write (adapt_desc
, tempbuf
, strlen (tempbuf
));
933 for (i
=0 ; i
<4 ; i
++) { /* SR0 - SR14 */
934 sprintf (tempbuf
, "SR%3d",i
*4);
936 for (j
=0 ; j
< (i
==3 ? 3 : 4) ; j
++)
937 sreg_buf
[i
*4 + j
] = get_hex_word();
941 * Read the pcs individually if we are in freeze mode.
942 * See get_reg_name(), it translates the register names for the pcs to
943 * the names of the shadow pcs.
946 sreg_buf
[10] = read_register(NPC_REGNUM
); /* pc0 */
947 sreg_buf
[11] = read_register(PC_REGNUM
); /* pc1 */
948 sreg_buf
[12] = read_register(PC2_REGNUM
); /* pc2 */
950 for (i
=0 ; i
<14 ; i
++) /* Supply vab -> lru */
951 supply_register(VAB_REGNUM
+i
,&sreg_buf
[i
]);
952 sprintf (tempbuf
, "dw sr128\r");
953 write (adapt_desc
, tempbuf
, strlen (tempbuf
));
954 for (i
=0 ; i
<2 ; i
++) { /* SR128 - SR135 */
955 sprintf (tempbuf
, "SR%3d",128 + i
*4);
957 for (j
=0 ; j
<4 ; j
++)
958 sreg_buf
[i
*4 + j
] = get_hex_word();
961 supply_register(IPC_REGNUM
,&sreg_buf
[0]);
962 supply_register(IPA_REGNUM
,&sreg_buf
[1]);
963 supply_register(IPB_REGNUM
,&sreg_buf
[2]);
964 supply_register(Q_REGNUM
, &sreg_buf
[3]);
966 supply_register(BP_REGNUM
, &sreg_buf
[5]);
967 supply_register(FC_REGNUM
, &sreg_buf
[6]);
968 supply_register(CR_REGNUM
, &sreg_buf
[7]);
970 /* There doesn't seem to be any way to get these. */
973 supply_register (FPE_REGNUM
, &val
);
974 supply_register (INT_REGNUM
, &val
);
975 supply_register (FPS_REGNUM
, &val
);
976 supply_register (EXO_REGNUM
, &val
);
979 write (adapt_desc
, "dw gr1,gr1\r", 11);
981 get_hex_regs (1, GR1_REGNUM
);
984 DEXIT("adapt_fetch_registers()");
987 /* Fetch register REGNO, or all registers if REGNO is -1.
990 adapt_fetch_register (regno
)
993 DENTER("adapt_fetch_register()");
995 adapt_fetch_registers ();
998 char *name
= get_reg_name (regno
);
999 fprintf (adapt_stream
, "dw %s,%s\r", name
, name
);
1002 get_hex_regs (1, regno
);
1005 DEXIT("adapt_fetch_register()");
1008 /* Store the remote registers from the contents of the block REGS. */
1011 adapt_store_registers ()
1015 DENTER("adapt_store_registers()");
1016 fprintf (adapt_stream
, "s gr1,%x\r", read_register (GR1_REGNUM
));
1019 #if defined(GR64_REGNUM)
1020 for (j
= 0; j
< 32; j
+= 16)
1022 fprintf (adapt_stream
, "s gr%d,", j
+ 64);
1023 for (i
= 0; i
< 15; ++i
)
1024 fprintf (adapt_stream
, "%x,", read_register (GR64_REGNUM
+ j
+ i
));
1025 fprintf (adapt_stream
, "%x\r", read_register (GR64_REGNUM
+ j
+ 15));
1029 for (j
= 0; j
< 32; j
+= 16)
1031 fprintf (adapt_stream
, "s gr%d,", j
+ 96);
1032 for (i
= 0; i
< 15; ++i
)
1033 fprintf (adapt_stream
, "%x,", read_register (GR96_REGNUM
+ j
+ i
));
1034 fprintf (adapt_stream
, "%x\r", read_register (GR96_REGNUM
+ j
+ 15));
1038 for (j
= 0; j
< 128; j
+= 16)
1040 fprintf (adapt_stream
, "s lr%d,", j
);
1041 for (i
= 0; i
< 15; ++i
)
1042 fprintf (adapt_stream
, "%x,", read_register (LR0_REGNUM
+ j
+ i
));
1043 fprintf (adapt_stream
, "%x\r", read_register (LR0_REGNUM
+ j
+ 15));
1047 fprintf (adapt_stream
, "s sr128,%x,%x,%x\r", read_register (IPC_REGNUM
),
1048 read_register (IPA_REGNUM
), read_register (IPB_REGNUM
));
1050 fprintf (adapt_stream
, "s sr133,%x,%x,%x\r", read_register (BP_REGNUM
),
1051 read_register (FC_REGNUM
), read_register (CR_REGNUM
));
1053 fprintf (adapt_stream
, "s sr131,%x\r", read_register (Q_REGNUM
));
1055 fprintf (adapt_stream
, "s sr0,");
1056 for (i
=0 ; i
<7 ; ++i
)
1057 fprintf (adapt_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
1059 fprintf (adapt_stream
, "s sr7,");
1060 for (i
=7; i
<14 ; ++i
)
1061 fprintf (adapt_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
1065 /* Store register REGNO, or all if REGNO == -1.
1066 Return errno value. */
1068 adapt_store_register (regno
)
1071 /* printf("adapt_store_register() called.\n"); fflush(stdout); /* */
1073 adapt_store_registers ();
1076 char *name
= get_reg_name (regno
);
1077 fprintf (adapt_stream
, "s %s,%x\r", name
, read_register (regno
));
1078 /* Setting GR1 changes the numbers of all the locals, so
1079 invalidate the register cache. Do this *after* calling
1080 read_register, because we want read_register to return the
1081 value that write_register has just stuffed into the registers
1082 array, not the value of the register fetched from the
1084 if (regno
== GR1_REGNUM
)
1085 registers_changed ();
1088 DEXIT("adapt_store_registers()");
1092 /* Get ready to modify the registers array. On machines which store
1093 individual registers, this doesn't need to do anything. On machines
1094 which store all the registers in one fell swoop, this makes sure
1095 that registers contains all the registers from the program being
1099 adapt_prepare_to_store ()
1101 /* Do nothing, since we can store individual regs */
1105 translate_addr(addr
)
1108 #if defined(KERNEL_DEBUGGING)
1109 /* Check for a virtual address in the kernel */
1110 /* Assume physical address of ublock is in paddr_u register */
1111 if (addr
>= UVADDR
) {
1112 /* PADDR_U register holds the physical address of the ublock */
1113 CORE_ADDR i
= (CORE_ADDR
)read_register(PADDR_U_REGNUM
);
1114 return(i
+ addr
- (CORE_ADDR
)UVADDR
);
1124 /* FIXME! Merge these two. */
1126 adapt_xfer_inferior_memory (memaddr
, myaddr
, len
, write
)
1133 memaddr
= translate_addr(memaddr
);
1136 return adapt_write_inferior_memory (memaddr
, myaddr
, len
);
1138 return adapt_read_inferior_memory (memaddr
, myaddr
, len
);
1144 printf_filtered("\tAttached to %s at %d baud and running program %s\n",
1145 dev_name
, baudrate
, prog_name
);
1146 printf_filtered("\ton an %s processor.\n", processor_name
[processor_type
]);
1149 /* Copy LEN bytes of data from debugger memory at MYADDR
1150 to inferior's memory at MEMADDR. Returns errno value.
1151 * sb/sh instructions don't work on unaligned addresses, when TU=1.
1154 adapt_write_inferior_memory (memaddr
, myaddr
, len
)
1162 /* DENTER("adapt_write_inferior_memory()"); */
1164 /* Turn TU bit off so we can do 'sb' commands */
1165 cps
= read_register(CPS_REGNUM
);
1166 if (cps
& 0x00000800)
1167 write_register(CPS_REGNUM
,cps
&~(0x00000800));
1169 for (i
= 0; i
< len
; i
++)
1172 fprintf (adapt_stream
, "sb %x,", memaddr
+ i
);
1173 if ((i
% 16) == 15 || i
== len
- 1)
1175 fprintf (adapt_stream
, "%x\r", ((unsigned char *)myaddr
)[i
]);
1179 fprintf (adapt_stream
, "%x,", ((unsigned char *)myaddr
)[i
]);
1181 /* Restore the old value of cps if the TU bit was on */
1182 if (cps
& 0x00000800)
1183 write_register(CPS_REGNUM
,cps
);
1184 /* DEXIT("adapt_write_inferior_memory()"); */
1188 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
1189 at debugger address MYADDR. Returns errno value. */
1191 adapt_read_inferior_memory(memaddr
, myaddr
, len
)
1198 /* Number of bytes read so far. */
1201 /* Starting address of this pass. */
1202 unsigned long startaddr
;
1204 /* Number of bytes to read in this pass. */
1207 /* Note that this code works correctly if startaddr is just less
1208 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
1209 thing). That is, something like
1210 adapt_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
1211 works--it never adds len to memaddr and gets 0. */
1212 /* However, something like
1213 adapt_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
1214 doesn't need to work. Detect it and give up if there's an attempt
1216 /* DENTER("adapt_read_inferior_memory()"); */
1218 if (((memaddr
- 1) + len
) < memaddr
)
1221 startaddr
= memaddr
;
1226 if ((startaddr
% 16) != 0)
1227 len_this_pass
-= startaddr
% 16;
1228 if (len_this_pass
> (len
- count
))
1229 len_this_pass
= (len
- count
);
1231 fprintf (adapt_stream
, "db %x,%x\r", startaddr
,
1232 (startaddr
- 1) + len_this_pass
);
1234 #ifdef NOTDEF /* Why do this */
1236 /* Look for 8 hex digits. */
1240 if (isxdigit (readchar ()))
1245 error ("Hex digit expected from remote system.");
1254 for (i
= 0; i
< len_this_pass
; i
++)
1255 get_hex_byte (&myaddr
[count
++]);
1259 startaddr
+= len_this_pass
;
1262 /* DEXIT("adapt_read_inferior_memory()"); */
1266 #define MAX_BREAKS 8
1267 static int num_brkpts
=0;
1269 adapt_insert_breakpoint(addr
, save
)
1271 char *save
; /* Throw away, let adapt save instructions */
1273 DENTER("adapt_insert_breakpoint()");
1274 if (num_brkpts
< MAX_BREAKS
) {
1276 fprintf (adapt_stream
, "B %x", addr
);
1277 fprintf (adapt_stream
, "\r");
1279 DEXIT("adapt_insert_breakpoint() success");
1280 return(0); /* Success */
1282 fprintf_filtered(stderr
,
1283 "Too many break points, break point not installed\n");
1284 DEXIT("adapt_insert_breakpoint() failure");
1285 return(1); /* Failure */
1290 adapt_remove_breakpoint(addr
, save
)
1292 char *save
; /* Throw away, let adapt save instructions */
1294 DENTER("adapt_remove_breakpoint()");
1295 if (num_brkpts
> 0) {
1297 fprintf (adapt_stream
, "BR %x", addr
);
1298 fprintf (adapt_stream
, "\r");
1299 fflush (adapt_stream
);
1302 DEXIT("adapt_remove_breakpoint()");
1306 /* Clear the adapts notion of what the break points are */
1308 adapt_clear_breakpoints()
1310 DENTER("adapt_clear_breakpoint()");
1312 fprintf (adapt_stream
, "BR"); /* Clear all break points */
1313 fprintf (adapt_stream
, "\r");
1314 fflush(adapt_stream
);
1318 DEXIT("adapt_clear_breakpoint()");
1323 DENTER("adapt_mourn()");
1324 adapt_clear_breakpoints();
1325 pop_target (); /* Pop back to no-child state */
1326 generic_mourn_inferior ();
1327 DEXIT("adapt_mourn()");
1330 /* Display everthing we read in from the adapt until we match/see the
1339 while (c
=readchar()) {
1342 if (i
== strlen(str
)) return;
1345 for (j
=0 ; j
<i
; j
++) /* Put everthing we matched */
1356 /* Put a command string, in args, out to the adapt. The adapt is assumed to
1357 be in raw mode, all writing/reading done through adapt_desc.
1358 Ouput from the adapt is placed on the users terminal until the
1359 prompt from the adapt is seen.
1360 FIXME: Can't handle commands that take input. */
1363 adapt_com (args
, fromtty
)
1367 if (!adapt_stream
) {
1368 printf_filtered("Adapt not open. Use the 'target' command to open.\n");
1372 /* Clear all input so only command relative output is displayed */
1375 switch(islower(args
[0]) ? toupper(args
[0]) : args
[0]) {
1377 printf_filtered("Unknown/Unimplemented adapt command '%s'\n",args
);
1379 case 'G': /* Go, begin execution */
1380 write(adapt_desc
,args
,strlen(args
));
1381 write(adapt_desc
,"\r",1);
1384 case 'B': /* Break points, B or BR */
1385 case 'C': /* Check current 29k status (running/halted) */
1386 case 'D': /* Display data/registers */
1387 case 'I': /* Input from i/o space */
1388 case 'J': /* Jam an instruction */
1389 case 'K': /* Kill, stop execution */
1390 case 'L': /* Disassemble */
1391 case 'O': /* Output to i/o space */
1392 case 'T': /* Trace */
1393 case 'P': /* Pulse an input line */
1394 case 'X': /* Examine special purpose registers */
1395 case 'Z': /* Display trace buffer */
1396 write(adapt_desc
,args
,strlen(args
));
1397 write(adapt_desc
,"\r",1);
1398 expect(args
); /* Don't display the command */
1399 display_until("# ");
1401 /* Begin commands that take input in the form 'c x,y[,z...]' */
1402 case 'S': /* Set memory or register */
1403 if (index(args
,',')) { /* Assume it is properly formatted */
1404 write(adapt_desc
,args
,strlen(args
));
1405 write(adapt_desc
,"\r",1);
1412 /* Define the target subroutine names */
1414 struct target_ops adapt_ops
= {
1415 "adapt", "Remote AMD `Adapt' target",
1416 "Remote debug an AMD 290*0 using an `Adapt' monitor via RS232",
1417 adapt_open
, adapt_close
,
1418 adapt_attach
, adapt_detach
, adapt_resume
, adapt_wait
,
1419 adapt_fetch_register
, adapt_store_register
,
1420 adapt_prepare_to_store
, 0, 0, /* conv_to, conv_from */
1421 adapt_xfer_inferior_memory
,
1423 adapt_insert_breakpoint
, adapt_remove_breakpoint
, /* Breakpoints */
1424 0, 0, 0, 0, 0, /* Terminal handling */
1425 adapt_kill
, /* FIXME, kill */
1427 0, /* lookup_symbol */
1428 adapt_create_inferior
, /* create_inferior */
1429 adapt_mourn
, /* mourn_inferior FIXME */
1430 process_stratum
, 0, /* next */
1431 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
1432 0,0, /* Section pointers */
1433 OPS_MAGIC
, /* Always the last thing */
1437 _initialize_remote_adapt ()
1439 add_target (&adapt_ops
);
1440 add_com ("adapt <command>", class_obscure
, adapt_com
,
1441 "Send a command to the AMD Adapt remote monitor.");