1 /* Memory-access and commands for remote es1800 processes, for GDB.
2 Copyright (C) 1988, 1992, 2001 Free Software Foundation, Inc.
4 This file is added to GDB to make it possible to do debugging via an
5 ES-1800 emulator. The code was originally written by Johan Holmberg
6 TT/SJ Ericsson Telecom AB and later modified by Johan Henriksson
7 TT/SJ. It was modified for gdb 4.0 by TX/DK Jan Nordenand by TX/DKG
10 This file is part of GDB.
12 GDB is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 1, or (at your option)
17 GDB is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 59 Temple Place - Suite 330,
25 Boston, MA 02111-1307, USA. */
28 /* Emulator communication protocol.
29 All values are encoded in ascii hex digits.
36 - 0 - - 1 - - 2 - - 3 - - 4 - - 5 - -- 6 - - 7 -
37 D = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
38 A = XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXXXX
39 PC = XXXXXX SSP = XXXXXX USP = XXXXXX SR = XXXXXXXX
41 Each byte of register data is described by two hex digits.
63 Each byte of register data is described by two hex digits.
69 AA..AA is address, XXXXXXX is the contents
74 AA..AA is address, XXXXXXXX is data
80 AA..AA is address to resume. If AA..AA is omitted, resume at same address.
86 AA..AA is address to resume. If AA..AA is omitted, resume at same address.
96 #include <sys/ioctl.h>
103 #include "gdb_string.h"
105 #include "inferior.h"
109 #include "remote-utils.h"
112 #include "regcache.h"
114 /* Prototypes for local functions */
116 static void es1800_child_detach (char *, int);
118 static void es1800_child_open (char *, int);
120 static void es1800_transparent (char *, int);
122 static void es1800_create_inferior (char *, char *, char **);
124 static void es1800_load (char *, int);
126 static void es1800_kill (void);
128 static int verify_break (int);
130 static int es1800_remove_breakpoint (CORE_ADDR
, char *);
132 static int es1800_insert_breakpoint (CORE_ADDR
, char *);
134 static void es1800_files_info (struct target_ops
*);
137 es1800_xfer_inferior_memory (CORE_ADDR
, char *, int, int,
138 struct mem_attrib
*, struct target_ops
*);
140 static void es1800_prepare_to_store (void);
142 static int es1800_wait (int, struct target_waitstatus
*);
144 static void es1800_resume (int, int, enum target_signal
);
146 static void es1800_detach (char *, int);
148 static void es1800_attach (char *, int);
150 static int damn_b (char *);
152 static void es1800_open (char *, int);
154 static void es1800_timer (void);
156 static void es1800_reset (char *);
158 static void es1800_request_quit (void);
160 static int readchar (void);
162 static void expect (char *, int);
164 static void expect_prompt (void);
166 static void download (FILE *, int, int);
169 static void bfd_copy (bfd
*, bfd
*);
172 static void get_break_addr (int, CORE_ADDR
*);
174 static int fromhex (int);
176 static int tohex (int);
178 static void es1800_close (int);
180 static void es1800_fetch_registers (void);
182 static void es1800_fetch_register (int);
184 static void es1800_store_register (int);
186 static void es1800_read_bytes (CORE_ADDR
, char *, int);
188 static void es1800_write_bytes (CORE_ADDR
, char *, int);
190 static void send_with_reply (char *, char *, int);
192 static void send_command (char *);
194 static void send (char *);
196 static void getmessage (char *, int);
198 static void es1800_mourn_inferior (void);
200 static void es1800_create_break_insn (char *, int);
202 static void es1800_init_break (char *, int);
204 /* Local variables */
206 /* FIXME: Convert this to use "set remotedebug" instead. */
207 #define LOG_FILE "es1800.log"
208 #if defined (LOG_FILE)
209 static FILE *log_file
;
212 extern struct target_ops es1800_ops
; /* Forward decl */
213 extern struct target_ops es1800_child_ops
; /* Forward decl */
216 static int timeout
= 100;
217 static char *savename
; /* Name of i/o device used */
218 static serial_ttystate es1800_saved_ttystate
;
219 static int es1800_fc_save
; /* Save fcntl state */
221 /* indicates that the emulator uses 32-bit data-adress (68020-mode)
222 instead of 24-bit (68000 -mode) */
226 #define MODE (m68020 ? "M68020" : "M68000" )
227 #define ES1800_BREAK_VEC (0xf)
229 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
230 es1800_open knows that we don't have a file open when the program
233 static serial_t es1800_desc
= NULL
;
236 #define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
238 /* Maximum number of bytes to read/write at once. The value here
239 is chosen to fill up a packet. */
241 #define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
243 static int es1800_break_vec
= 0;
244 static char es1800_break_insn
[2];
245 static long es1800_break_address
;
246 static void (*old_sigint
) (); /* Old signal-handler for sigint */
247 static jmp_buf interrupt
;
249 /* Local signalhandler to allow breaking tranfers or program run.
250 Rely on global variables: old_sigint(), interrupt */
253 es1800_request_quit (void)
255 /* restore original signalhandler */
256 signal (SIGINT
, old_sigint
);
257 longjmp (interrupt
, 1);
262 Sending reset character(octal 32) to emulator.
263 quit - return to '(esgdb)' prompt or continue */
266 es1800_reset (char *quit
)
272 printf ("\nResetting emulator... ");
274 strcpy (buf
, "\032");
284 /* Open a connection to a remote debugger and push the new target
285 onto the stack. Check if the emulator is responding and find out
286 what kind of processor the emulator is connected to.
287 Initiate the breakpoint handling in the emulator.
289 name - the filename used for communication (ex. '/dev/tta')
290 from_tty - says whether to be verbose or not */
293 es1800_open (char *name
, int from_tty
)
301 if (!name
) /* no device name given in target command */
303 error_no_arg ("serial port device name");
306 target_preopen (from_tty
);
309 /* open the device and configure it for communication */
313 es1800_desc
= SERIAL_OPEN (name
);
314 if (es1800_desc
== NULL
)
316 perror_with_name (name
);
318 savename
= savestring (name
, strlen (name
));
320 es1800_saved_ttystate
= SERIAL_GET_TTY_STATE (es1800_desc
);
322 if ((fcflag
= fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_GETFL
, 0)) == -1)
324 perror_with_name ("fcntl serial");
326 es1800_fc_save
= fcflag
;
328 fcflag
= (fcflag
& (FREAD
| FWRITE
)); /* mask out any funny stuff */
329 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, fcflag
) == -1)
331 perror_with_name ("fcntl serial");
336 if (SERIAL_SETBAUDRATE (es1800_desc
, baud_rate
))
338 SERIAL_CLOSE (es1800_desc
);
339 perror_with_name (name
);
343 SERIAL_RAW (es1800_desc
);
345 /* If there is something sitting in the buffer we might take it as a
346 response to a command, which would be bad. */
347 SERIAL_FLUSH_INPUT (es1800_desc
);
349 #endif /* DEBUG_STDIN */
351 push_target (&es1800_ops
); /* Switch to using remote target now */
354 printf ("Remote ES1800 debugging using %s\n", name
);
357 #if defined (LOG_FILE)
359 log_file
= fopen (LOG_FILE
, "w");
360 if (log_file
== NULL
)
362 perror_with_name (LOG_FILE
);
365 #endif /* LOG_FILE */
367 /* Hello? Are you there?, also check mode */
369 /* send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
370 /* for (p = buf, i = 0; *p++ =='0';) *//* count the number of zeros */
374 getmessage (buf
, sizeof (buf
)); /* send reset character */
378 printf ("Checking mode.... ");
380 /* m68020 = (i==8); *//* if eight zeros then we are in m68020 mode */
382 /* What kind of processor am i talking to ? */
393 for (i
= 0; i
< 20; i
++, p
++)
396 m68020
= !strncmp (p
, "68020", 5);
399 printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE
, p
[0], p
[1], p
[2],
403 /* if no init_break statement is present in .gdb file we have to check
404 whether to download a breakpoint routine or not */
407 if ((es1800_break_vec
== 0) || (verify_break (es1800_break_vec
) != 0)
408 && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
410 CORE_ADDR memaddress
;
411 printf ("Give the start address of the breakpoint routine: ");
412 scanf ("%li", &memaddress
);
413 es1800_init_break ((es1800_break_vec
? es1800_break_vec
:
414 ES1800_BREAK_VEC
), memaddress
);
420 /* Close out all files and local state before this target loses control.
421 quitting - are we quitting gdb now? */
424 es1800_close (int quitting
)
426 if (es1800_desc
!= NULL
)
428 printf ("\nClosing connection to emulator...\n");
429 if (SERIAL_SET_TTY_STATE (es1800_desc
, es1800_saved_ttystate
) < 0)
430 print_sys_errmsg ("warning: unable to restore tty state", errno
);
431 fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, es1800_fc_save
);
432 SERIAL_CLOSE (es1800_desc
);
435 if (savename
!= NULL
)
441 #if defined (LOG_FILE)
443 if (log_file
!= NULL
)
445 if (ferror (log_file
))
447 printf ("Error writing log file.\n");
449 if (fclose (log_file
) != 0)
451 printf ("Error closing log file.\n");
456 #endif /* LOG_FILE */
460 /* Attaches to a process on the target side
461 proc_id - the id of the process to be attached.
462 from_tty - says whether to be verbose or not */
465 es1800_attach (char *args
, int from_tty
)
467 error ("Cannot attach to pid %s, this feature is not implemented yet.",
472 /* Takes a program previously attached to and detaches it.
473 We better not have left any breakpoints
474 in the program or it'll die when it hits one.
475 Close the open connection to the remote debugger.
476 Use this when you want to detach and do something else
479 args - arguments given to the 'detach' command
480 from_tty - says whether to be verbose or not */
483 es1800_detach (char *args
, int from_tty
)
487 error ("Argument given to \"detach\" when remotely debugging.");
492 printf ("Ending es1800 remote debugging.\n");
497 /* Tell the remote machine to resume.
498 step - single-step or run free
499 siggnal - the signal value to be given to the target (0 = no signal) */
502 es1800_resume (int pid
, int step
, enum target_signal siggnal
)
508 error ("Can't send signals to a remote system.");
512 strcpy (buf
, "STP\r");
517 send_command ("RBK");
521 /* Wait until the remote machine stops, then return,
522 storing status in STATUS just as `wait' would.
526 es1800_wait (int pid
, struct target_waitstatus
*status
)
528 unsigned char buf
[PBUFSIZ
];
529 int old_timeout
= timeout
;
531 status
->kind
= TARGET_WAITKIND_EXITED
;
532 status
->value
.integer
= 0;
534 timeout
= 0; /* Don't time out -- user program is running. */
535 if (!setjmp (interrupt
))
537 old_sigint
= signal (SIGINT
, es1800_request_quit
);
540 getmessage (buf
, sizeof (buf
));
541 if (strncmp (buf
, "\r\n* BREAK *", 11) == 0)
543 status
->kind
= TARGET_WAITKIND_STOPPED
;
544 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
545 send_command ("STP"); /* Restore stack and PC and such */
548 send_command ("STP");
552 if (strncmp (buf
, "STP\r\n ", 6) == 0)
554 status
->kind
= TARGET_WAITKIND_STOPPED
;
555 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
558 if (buf
[strlen (buf
) - 2] == 'R')
560 printf ("Unexpected emulator reply: \n%s\n", buf
);
564 printf ("Unexpected stop: \n%s\n", buf
);
565 status
->kind
= TARGET_WAITKIND_STOPPED
;
566 status
->value
.sig
= TARGET_SIGNAL_QUIT
;
574 printf ("\nStopping emulator...");
575 if (!setjmp (interrupt
))
577 old_sigint
= signal (SIGINT
, es1800_request_quit
);
578 send_command ("STP");
579 printf (" emulator stopped\n");
580 status
->kind
= TARGET_WAITKIND_STOPPED
;
581 status
->value
.sig
= TARGET_SIGNAL_INT
;
586 es1800_reset ((char *) 1);
589 signal (SIGINT
, old_sigint
);
590 timeout
= old_timeout
;
595 /* Fetch register values from remote machine.
596 regno - the register to be fetched (fetch all registers if -1) */
599 es1800_fetch_register (int regno
)
605 static char regtab
[18][4] =
607 "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
608 "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
612 if ((regno
< 15) || (regno
== 16) || (regno
== 17))
615 send_with_reply (regtab
[regno
], buf
, sizeof (buf
));
617 for (k
= 0; k
< 4; k
++)
619 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
621 error ("Emulator reply is too short: %s", buf
);
623 registers
[r
++] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
628 es1800_fetch_registers ();
632 /* Read the remote registers into REGISTERS.
633 Always fetches all registers. */
636 es1800_fetch_registers (void)
639 char SR_buf
[PBUFSIZ
];
645 send_with_reply ("DR", buf
, sizeof (buf
));
647 /* Reply is edited to a string that describes registers byte by byte,
648 each byte encoded as two hex characters. */
653 /* parsing row one - D0-D7-registers */
658 for (i
= 4; i
< 70; i
+= (i
== 39 ? 3 : 1))
660 for (k
= 0; k
< 4; k
++)
662 if (p
[i
+ 0] == 0 || p
[i
+ 1] == 0)
664 error ("Emulator reply is too short: %s", buf
);
666 registers
[r
++] = (fromhex (p
[i
+ 0]) * 16) + fromhex (p
[i
+ 1]);
672 /* parsing row two - A0-A6-registers */
677 for (i
= 4; i
< 61; i
+= (i
== 39 ? 3 : 1))
679 for (k
= 0; k
< 4; k
++)
681 if (p
[i
+ 0] == 0 || p
[i
+ 1] == 0)
683 error ("Emulator reply is too short: %s", buf
);
685 registers
[r
++] = (fromhex (p
[i
+ 0])) * 16 + fromhex (p
[i
+ 1]);
695 /* fetch SSP-, SR- and PC-registers */
697 /* first - check STATUS-word and decide which stackpointer to use */
699 send_with_reply ("SR", SR_buf
, sizeof (SR_buf
));
705 if (*p
== '3') /* use masterstackpointer MSP */
707 send_with_reply ("MSP", buf
, sizeof (buf
));
709 else if (*p
== '2') /* use interruptstackpointer ISP */
711 send_with_reply ("ISP", buf
, sizeof (buf
));
714 /* use userstackpointer USP */
716 send_with_reply ("USP", buf
, sizeof (buf
));
719 for (k
= 0; k
< 4; k
++)
721 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
723 error ("Emulator reply is too short: %s", buf
);
725 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
729 for (k
= 0; k
< 4; k
++)
731 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
733 error ("Emulator reply is too short: %s", buf
);
736 fromhex (SR_buf
[k
* 2 + 1]) * 16 + fromhex (SR_buf
[k
* 2 + 2]);
738 send_with_reply ("PC", buf
, sizeof (buf
));
740 for (k
= 0; k
< 4; k
++)
742 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
744 error ("Emulator reply is too short: %s", buf
);
746 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
752 if (*p
== '2') /* use supervisorstackpointer SSP */
754 send_with_reply ("SSP", buf
, sizeof (buf
));
757 /* use userstackpointer USP */
759 send_with_reply ("USP", buf
, sizeof (buf
));
762 /* fetch STACKPOINTER */
765 for (k
= 0; k
< 4; k
++)
767 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
769 error ("Emulator reply is too short: %s", buf
);
771 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
777 for (k
= 0; k
< 4; k
++)
779 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
781 error ("Emulator reply is too short: %s", buf
);
784 fromhex (SR_buf
[k
* 2 + 1]) * 16 + fromhex (SR_buf
[k
* 2 + 2]);
789 send_with_reply ("PC", buf
, sizeof (buf
));
791 for (k
= 0; k
< 4; k
++)
793 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
795 error ("Emulator reply is too short: %s", buf
);
797 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
802 /* Store register value, located in REGISTER, on the target processor.
803 regno - the register-number of the register to store
804 (-1 means store them all)
805 FIXME: Return errno value. */
808 es1800_store_register (int regno
)
811 static char regtab
[18][4] =
813 "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
814 "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
819 char SR_buf
[PBUFSIZ
];
820 char stack_pointer
[4];
827 r
= (unsigned char *) registers
;
829 if (regno
== -1) /* write all registers */
835 /* write one register */
842 if ((regno
== -1) || (regno
== 15))
844 /* fetch current status */
845 send_with_reply ("SR", SR_buf
, sizeof (SR_buf
));
850 if (*p
== '3') /* use masterstackpointer MSP */
852 strcpy (stack_pointer
, "MSP");
856 if (*p
== '2') /* use interruptstackpointer ISP */
858 strcpy (stack_pointer
, "ISP");
862 strcpy (stack_pointer
, "USP"); /* use userstackpointer USP */
869 if (*p
== '2') /* use supervisorstackpointer SSP */
871 strcpy (stack_pointer
, "SSP");
875 strcpy (stack_pointer
, "USP"); /* use userstackpointer USP */
878 strcpy (regtab
[15], stack_pointer
);
881 for (i
= j
; i
< k
; i
++)
883 buf
[0] = regtab
[i
][0];
884 buf
[1] = regtab
[i
][1];
885 buf
[2] = regtab
[i
][2];
888 buf
[5] = tohex ((*r
>> 4) & 0x0f);
889 buf
[6] = tohex (*r
++ & 0x0f);
890 buf
[7] = tohex ((*r
>> 4) & 0x0f);
891 buf
[8] = tohex (*r
++ & 0x0f);
892 buf
[9] = tohex ((*r
>> 4) & 0x0f);
893 buf
[10] = tohex (*r
++ & 0x0f);
894 buf
[11] = tohex ((*r
>> 4) & 0x0f);
895 buf
[12] = tohex (*r
++ & 0x0f);
898 send_with_reply (buf
, buf
, sizeof (buf
)); /* FIXME, reply not used? */
903 /* Prepare to store registers. */
906 es1800_prepare_to_store (void)
908 /* Do nothing, since we can store individual regs */
911 /* Convert hex digit A to a number. */
916 if (a
>= '0' && a
<= '9')
920 else if (a
>= 'a' && a
<= 'f')
924 else if (a
>= 'A' && a
<= 'F')
930 error ("Reply contains invalid hex digit");
936 /* Convert number NIB to a hex digit. */
947 return ('A' + nib
- 10);
951 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
952 to or from debugger address MYADDR. Write to inferior if WRITE is
953 nonzero. Returns length of data written or read; 0 for error.
955 memaddr - the target's address
956 myaddr - gdb's address
957 len - number of bytes
958 write - write if != 0 otherwise read
962 es1800_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
964 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
965 struct target_ops
*target ATTRIBUTE_UNUSED
)
972 xfersize
= len
> MAXBUFBYTES
? MAXBUFBYTES
: len
;
975 es1800_write_bytes (memaddr
, myaddr
, xfersize
);
979 es1800_read_bytes (memaddr
, myaddr
, xfersize
);
985 return (origlen
); /* no error possible */
989 /* Write memory data directly to the emulator.
990 This does not inform the data cache; the data cache uses this.
991 MEMADDR is the address in the remote memory space.
992 MYADDR is the address of the buffer in our space.
993 LEN is the number of bytes.
995 memaddr - the target's address
996 myaddr - gdb's address
997 len - number of bytes */
1000 es1800_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1007 for (i
= 0; i
< len
; i
++)
1009 sprintf (buf
, "@.B$%x=$%x", memaddr
+ i
, (*p
++) & 0xff);
1010 send_with_reply (buf
, buf
, sizeof (buf
)); /* FIXME send_command? */
1015 /* Read memory data directly from the emulator.
1016 This does not use the data cache; the data cache uses this.
1018 memaddr - the target's address
1019 myaddr - gdb's address
1020 len - number of bytes */
1023 es1800_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1025 static int DB_tab
[16] =
1026 {8, 11, 14, 17, 20, 23, 26, 29, 34, 37, 40, 43, 46, 49, 52, 55};
1033 if (len
> PBUFSIZ
/ 2 - 1)
1035 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
1038 if (len
== 1) /* The emulator does not like expressions like: */
1040 len
= 2; /* DB.B $20018 TO $20018 */
1043 /* Reply describes registers byte by byte, each byte encoded as two hex
1046 sprintf (buf
, "DB.B $%x TO $%x", memaddr
, memaddr
+ len
- 1);
1047 send_with_reply (buf
, buf
, sizeof (buf
));
1049 low_addr
= memaddr
& 0x0f;
1050 for (i
= low_addr
; i
< low_addr
+ len
; i
++)
1052 if ((!(i
% 16)) && i
)
1053 { /* if (i = 16,32,48) */
1054 while (*p
++ != '\n')
1059 p
= b
+ DB_tab
[i
% 16] + (m68020
? 2 : 0);
1060 if (p
[0] == 32 || p
[1] == 32)
1062 error ("Emulator reply is too short: %s", buf
);
1064 myaddr
[i
- low_addr
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1068 /* Display information about the current target. TOPS is unused. */
1071 es1800_files_info (struct target_ops
*tops
)
1073 printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename
, 19200,
1078 /* We read the contents of the target location and stash it,
1079 then overwrite it with a breakpoint instruction.
1081 addr - is the target location in the target machine.
1082 contents_cache - is a pointer to memory allocated for saving the target contents.
1083 It is guaranteed by the caller to be long enough to save sizeof
1086 FIXME: This size is target_arch dependent and should be available in
1087 the target_arch transfer vector, if we ever have one... */
1090 es1800_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1094 val
= target_read_memory (addr
, contents_cache
, sizeof (es1800_break_insn
));
1098 val
= target_write_memory (addr
, es1800_break_insn
,
1099 sizeof (es1800_break_insn
));
1106 /* Write back the stashed instruction
1108 addr - is the target location in the target machine.
1109 contents_cache - is a pointer to memory allocated for saving the target contents.
1110 It is guaranteed by the caller to be long enough to save sizeof
1111 BREAKPOINT bytes. */
1114 es1800_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1117 return (target_write_memory (addr
, contents_cache
,
1118 sizeof (es1800_break_insn
)));
1121 /* create_break_insn ()
1122 Primitive datastructures containing the es1800 breakpoint instruction */
1125 es1800_create_break_insn (char *ins
, int vec
)
1136 Seach for breakpoint routine in emulator memory.
1137 returns non-zero on failure
1138 vec - trap vector used for breakpoints */
1141 verify_break (int vec
)
1143 CORE_ADDR memaddress
;
1145 char *instr
= "NqNqNqNs"; /* breakpoint routine */
1148 get_break_addr (vec
, &memaddress
);
1152 status
= target_read_memory (memaddress
, buf
, 8);
1155 memory_error (status
, memaddress
);
1157 return (strcmp (instr
, buf
));
1163 /* get_break_addr ()
1164 find address of breakpoint routine
1165 vec - trap vector used for breakpoints
1166 addrp - store the address here */
1169 get_break_addr (int vec
, CORE_ADDR
*addrp
)
1171 CORE_ADDR memaddress
= 0;
1180 send_with_reply ("VBR ", buf
, sizeof (buf
));
1182 for (k
= 0; k
< 4; k
++)
1184 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
1186 error ("Emulator reply is too short: %s", buf
);
1188 base_addr
[k
] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
1190 /* base addr of exception vector table */
1191 memaddress
= *((CORE_ADDR
*) base_addr
);
1194 memaddress
+= (vec
+ 32) * 4; /* address of trap vector */
1195 status
= target_read_memory (memaddress
, (char *) addrp
, 4);
1198 memory_error (status
, memaddress
);
1203 /* Kill an inferior process */
1208 if (inferior_pid
!= 0)
1211 es1800_mourn_inferior ();
1216 /* Load a file to the ES1800 emulator.
1217 Converts the file from a.out format into Extended Tekhex format
1218 before the file is loaded.
1219 Also loads the trap routine, and sets the ES1800 breakpoint on it
1220 filename - the a.out to be loaded
1221 from_tty - says whether to be verbose or not
1222 FIXME Uses emulator overlay memory for trap routine */
1225 es1800_load (char *filename
, int from_tty
)
1231 struct cleanup
*old_chain
;
1232 int es1800_load_format
= 5;
1234 if (es1800_desc
== NULL
)
1236 printf ("No emulator attached, type emulator-command first\n");
1240 filename
= tilde_expand (filename
);
1241 make_cleanup (xfree
, filename
);
1243 switch (es1800_load_format
)
1245 case 2: /* Extended Tekhex */
1248 printf ("Converting \"%s\" to Extended Tekhex Format\n", filename
);
1250 sprintf (buf
, "tekhex %s", filename
);
1252 sprintf (loadname
, "out.hex");
1255 case 5: /* Motorola S-rec */
1258 printf ("Converting \"%s\" to Motorola S-record format\n",
1261 /* in the future the source code in copy (part of binutils-1.93) will
1262 be included in this file */
1264 "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
1267 sprintf (loadname
, "/tmp/out.hex");
1271 error ("Downloading format not defined\n");
1274 breakpoint_init_inferior ();
1278 printf ("Downloading \"%s\" to the ES 1800\n", filename
);
1280 if ((instream
= fopen (loadname
, "r")) == NULL
)
1282 perror_with_name ("fopen:");
1285 old_chain
= make_cleanup (fclose
, instream
);
1290 download (instream
, from_tty
, es1800_load_format
);
1292 /* if breakpoint routine is not present anymore we have to check
1293 whether to download a new breakpoint routine or not */
1295 if ((verify_break (es1800_break_vec
) != 0)
1296 && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
1299 printf ("Using break vector 0x%x\n", es1800_break_vec
);
1300 sprintf (buf
, "0x%x ", es1800_break_vec
);
1301 printf ("Give the start address of the breakpoint routine: ");
1302 fgets (buf
+ strlen (buf
), sizeof (buf
) - strlen (buf
), stdin
);
1303 es1800_init_break (buf
, 0);
1306 do_cleanups (old_chain
);
1308 readchar (); /* FIXME I am getting a ^G = 7 after the prompt */
1311 if (fclose (instream
) == EOF
)
1316 if (es1800_load_format
!= 2)
1318 sprintf (buf
, "/usr/bin/rm %s", loadname
);
1322 symbol_file_add_main (filename
, from_tty
); /* reading symbol table */
1328 #define NUMCPYBYTES 20
1331 bfd_copy (bfd
*from_bfd
, bfd
*to_bfd
)
1335 char buf
[NUMCPYBYTES
];
1337 for (p
= from_bfd
->sections
; p
!= NULL
; p
= p
->next
)
1339 printf (" Copying section %s. Size = %x.\n", p
->name
, p
->_cooked_size
);
1340 printf (" vma = %x, offset = %x, output_sec = %x\n",
1341 p
->vma
, p
->output_offset
, p
->output_section
);
1342 new = bfd_make_section (to_bfd
, p
->name
);
1343 if (p
->_cooked_size
&&
1344 !bfd_set_section_size (to_bfd
, new, p
->_cooked_size
))
1346 error ("Wrong BFD size!\n");
1348 if (!bfd_set_section_flags (to_bfd
, new, p
->flags
))
1350 error ("bfd_set_section_flags");
1354 for (i
= 0; (i
+ NUMCPYBYTES
) < p
->_cooked_size
; i
+= NUMCPYBYTES
)
1356 if (!bfd_get_section_contents (from_bfd
, p
, (PTR
) buf
, (file_ptr
) i
,
1357 (bfd_size_type
) NUMCPYBYTES
))
1359 error ("bfd_get_section_contents\n");
1361 if (!bfd_set_section_contents (to_bfd
, new, (PTR
) buf
, (file_ptr
) i
,
1362 (bfd_size_type
) NUMCPYBYTES
))
1364 error ("bfd_set_section_contents\n");
1367 bfd_get_section_contents (from_bfd
, p
, (PTR
) buf
, (file_ptr
) i
,
1368 (bfd_size_type
) (p
->_cooked_size
- i
));
1369 bfd_set_section_contents (to_bfd
, new, (PTR
) buf
, (file_ptr
) i
,
1370 (bfd_size_type
) (p
->_cooked_size
- i
));
1376 /* Start an process on the es1800 and set inferior_pid to the new
1378 execfile - the file to run
1379 args - arguments passed to the program
1380 env - the environment vector to pass */
1383 es1800_create_inferior (char *execfile
, char *args
, char **env
)
1388 struct expression
*expr
;
1389 register struct cleanup
*old_chain
= 0;
1395 error ("Can't pass arguments to remote ES1800 process");
1399 if (query ("Use 'start' as entry point? "))
1401 expr
= parse_c_expression ("start");
1402 old_chain
= make_cleanup (free_current_contents
, &expr
);
1403 val
= evaluate_expression (expr
);
1404 entry_pt
= (val
->location
).address
;
1408 printf ("Enter the program's entry point (in hexadecimal): ");
1409 scanf ("%x", &entry_pt
);
1413 if (execfile
== 0 || exec_bfd
== 0)
1415 error ("No executable file specified");
1418 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
1422 /* Now that we have a child process, make it our target. */
1424 push_target (&es1800_child_ops
);
1426 /* The "process" (board) is already stopped awaiting our commands, and
1427 the program is already downloaded. We just set its PC and go. */
1429 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
1431 clear_proceed_status ();
1433 /* Tell wait_for_inferior that we've started a new process. */
1435 init_wait_for_inferior ();
1437 /* Set up the "saved terminal modes" of the inferior
1438 based on what modes we are starting it with. */
1440 target_terminal_init ();
1442 /* Install inferior's terminal modes. */
1444 target_terminal_inferior ();
1446 /* remote_start (args); */
1447 /* trap_expected = 0; */
1448 /* insert_step_breakpoint (); FIXME, do we need this? */
1450 /* Let 'er rip... */
1451 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
1456 /* The process has died, clean up. */
1459 es1800_mourn_inferior (void)
1461 remove_breakpoints ();
1462 unpush_target (&es1800_child_ops
);
1463 generic_mourn_inferior (); /* Do all the proper things now */
1466 /* ES1800-protocol specific routines */
1468 /* Keep discarding input from the remote system, until STRING is found.
1469 Let the user break out immediately.
1470 string - the string to expect
1471 nowait - break out if string not the emulator's first respond otherwise
1472 read until string is found (== 0) */
1475 expect (char *string
, int nowait
)
1488 if (c
== toupper (*p
))
1503 printf ("\'%s\' expected\n", string
);
1504 printf ("char %d is %d", p
- string
, c
);
1510 /* Keep discarding input until we see the prompt. */
1513 expect_prompt (void)
1519 /* Read one character */
1523 /* read from stdin */
1531 printf ("readchar, give one character\n");
1534 #if defined (LOG_FILE)
1535 putc (buf
[0] & 0x7f, log_file
);
1538 return (buf
[0] & 0x7f);
1541 #else /* !DEBUG_STDIN */
1543 /* Read a character from the remote system, doing all the fancy
1551 ch
= SERIAL_READCHAR (es1800_desc
, timeout
);
1553 /* FIXME: doing an error() here will probably cause trouble, at least if from
1555 if (ch
== SERIAL_TIMEOUT
)
1556 error ("Timeout reading from remote system.");
1557 else if (ch
== SERIAL_ERROR
)
1558 perror_with_name ("remote read");
1560 #if defined (LOG_FILE)
1561 putc (ch
& 0x7f, log_file
);
1568 #endif /* DEBUG_STDIN */
1571 /* Send a command to the emulator and save the reply.
1572 Report an error if we get an error reply.
1573 string - the es1800 command
1574 buf - containing the emulator reply on return
1575 len - size of buf */
1578 send_with_reply (char *string
, char *buf
, int len
)
1581 SERIAL_WRITE (es1800_desc
, "\r", 1);
1588 getmessage (buf
, len
);
1592 /* Send the command in STR to the emulator adding \r. check
1593 the echo for consistency.
1594 string - the es1800 command */
1597 send_command (char *string
)
1600 SERIAL_WRITE (es1800_desc
, "\r", 1);
1610 string - the es1800 command */
1617 fprintf (stderr
, "Sending: %s\n", string
);
1619 SERIAL_WRITE (es1800_desc
, string
, strlen (string
));
1623 /* Read a message from the emulator and store it in BUF.
1624 buf - containing the emulator reply on return
1625 len - size of buf */
1628 getmessage (char *buf
, int len
)
1632 int prompt_found
= 0;
1635 #if defined (LOG_FILE)
1636 /* This is a convenient place to do this. The idea is to do it often
1637 enough that we never lose much data if we terminate abnormally. */
1647 if (len
-- < 2) /* char and terminaling NULL */
1649 error ("input buffer overrun\n");
1654 if ((c
== '>') && (*(bp
- 1) == ' '))
1659 while (!prompt_found
);
1664 fprintf (stderr
, "message received :%s\n", buf
);
1669 download (FILE *instream
, int from_tty
, int format
)
1675 send_command ("SET #2,$1A"); /* reset char = ^Z */
1676 send_command ("SET #3,$11,$13"); /* XON XOFF */
1679 send_command ("SET #26,#2");
1683 send_command ("SET #26,#5"); /* Format=Extended Tekhex */
1685 send_command ("DFB = $10");
1686 send_command ("PUR");
1687 send_command ("CES");
1692 printf (" 0 records loaded...\r");
1694 while (fgets (buf
, 160, instream
))
1699 printf ("%5d\b\b\b\b\b", ++i
);
1702 if ((c
= readchar ()) != 006)
1704 error ("expected ACK");
1713 /* Additional commands */
1715 #if defined (TIOCGETP) && defined (FNDELAY) && defined (EWOULDBLOCK)
1716 #define PROVIDE_TRANSPARENT
1719 #ifdef PROVIDE_TRANSPARENT
1720 /* Talk directly to the emulator
1721 FIXME, uses busy wait, and is SUNOS (or at least BSD) specific */
1725 es1800_transparent (char *args
, int from_tty
)
1728 struct sgttyb modebl
;
1731 struct sgttyb console_mode_save
;
1732 int console_fc_save
;
1737 char consolebuf
[80];
1739 char es1800_buf
[80];
1743 if (es1800_desc
== NULL
)
1745 printf ("No emulator attached, type emulator-command first\n");
1750 printf ("You are now communicating directly with the ES 1800 emulator.\n");
1751 printf ("To leave this mode (transparent mode), press ^E.\n");
1756 if ((console
= open ("/dev/tty", O_RDWR
)) == -1)
1758 perror_with_name ("/dev/tty:");
1761 if ((fcflag
= fcntl (console
, F_GETFL
, 0)) == -1)
1763 perror_with_name ("fcntl console");
1766 console_fc_save
= fcflag
;
1767 fcflag
= fcflag
| FNDELAY
;
1769 if (fcntl (console
, F_SETFL
, fcflag
) == -1)
1771 perror_with_name ("fcntl console");
1774 if (ioctl (console
, TIOCGETP
, &modebl
))
1776 perror_with_name ("ioctl console");
1779 console_mode_save
= modebl
;
1780 modebl
.sg_flags
= RAW
;
1782 if (ioctl (console
, TIOCSETP
, &modebl
))
1784 perror_with_name ("ioctl console");
1787 if ((fcflag
= fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_GETFL
, 0)) == -1)
1789 perror_with_name ("fcntl serial");
1792 es1800_fc_save
= fcflag
;
1793 fcflag
= fcflag
| FNDELAY
;
1795 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, fcflag
) == -1)
1797 perror_with_name ("fcntl serial");
1802 cc
= read (console
, inputbuf
, inputcnt
);
1805 if ((*inputbuf
& 0x7f) == 0x05)
1809 for (i
= 0; i
< cc
;)
1811 es1800_buf
[es1800_cnt
++] = inputbuf
[i
++];
1813 if ((cc
= SERIAL_WRITE (es1800_desc
, es1800_buf
, es1800_cnt
)) == -1)
1815 perror_with_name ("FEL! write:");
1818 if (es1800_cnt
&& cc
)
1820 for (i
= 0; i
< es1800_cnt
; i
++)
1822 es1800_buf
[i
] = es1800_buf
[cc
+ i
];
1826 else if (errno
!= EWOULDBLOCK
)
1828 perror_with_name ("FEL! read:");
1831 cc
= read (DEPRECATED_SERIAL_FD (es1800_desc
), inputbuf
, inputcnt
);
1834 for (i
= 0; i
< cc
;)
1836 consolebuf
[consolecnt
++] = inputbuf
[i
++];
1838 if ((cc
= write (console
, consolebuf
, consolecnt
)) == -1)
1840 perror_with_name ("FEL! write:");
1843 if (consolecnt
&& cc
)
1845 for (i
= 0; i
< consolecnt
; i
++)
1847 consolebuf
[i
] = consolebuf
[cc
+ i
];
1851 else if (errno
!= EWOULDBLOCK
)
1853 perror_with_name ("FEL! read:");
1857 console_fc_save
= console_fc_save
& !FNDELAY
;
1858 if (fcntl (console
, F_SETFL
, console_fc_save
) == -1)
1860 perror_with_name ("FEL! fcntl");
1863 if (ioctl (console
, TIOCSETP
, &console_mode_save
))
1865 perror_with_name ("FEL! ioctl");
1870 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, es1800_fc_save
) == -1)
1872 perror_with_name ("FEL! fcntl");
1878 #endif /* PROVIDE_TRANSPARENT */
1881 es1800_init_break (char *args
, int from_tty
)
1883 CORE_ADDR memaddress
= 0;
1892 error_no_arg ("a trap vector");
1895 if (!(space_index
= strchr (args
, ' ')))
1897 error ("Two arguments needed (trap vector and address of break routine).\n");
1900 *space_index
= '\0';
1902 es1800_break_vec
= strtol (args
, (char **) NULL
, 0);
1903 es1800_break_address
= parse_and_eval_address (space_index
+ 1);
1905 es1800_create_break_insn (es1800_break_insn
, es1800_break_vec
);
1909 send_with_reply ("VBR ", buf
, sizeof (buf
));
1911 for (k
= 0; k
< 4; k
++)
1913 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
1915 error ("Emulator reply is too short: %s", buf
);
1917 base_addr
[k
] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
1919 /* base addr of exception vector table */
1920 memaddress
= *((CORE_ADDR
*) base_addr
);
1923 memaddress
+= (es1800_break_vec
+ 32) * 4; /* address of trap vector */
1925 sprintf (buf
, "@.L%lx=$%lx", memaddress
, es1800_break_address
);
1926 send_command (buf
); /* set the address of the break routine in the */
1929 sprintf (buf
, "@.L%lx=$4E714E71", es1800_break_address
); /* NOP; NOP */
1931 sprintf (buf
, "@.L%lx=$4E714E73", es1800_break_address
+ 4); /* NOP; RTE */
1934 sprintf (buf
, "AC2=$%lx", es1800_break_address
+ 4);
1935 /* breakpoint at es1800-break_address */
1937 send_command ("WHEN AC2 THEN BRK"); /* ie in exception routine */
1941 printf ("Breakpoint (trap $%x) routine at address: %lx\n",
1942 es1800_break_vec
, es1800_break_address
);
1947 es1800_child_open (char *arg
, int from_tty
)
1949 error ("Use the \"run\" command to start a child process.");
1953 es1800_child_detach (char *args
, int from_tty
)
1957 error ("Argument given to \"detach\" when remotely debugging.");
1963 printf ("Ending debugging the process %d.\n", inferior_pid
);
1968 /* Define the target subroutine names */
1970 struct target_ops es1800_ops
;
1973 init_es1800_ops (void)
1975 es1800_ops
.to_shortname
= "es1800";
1976 es1800_ops
.to_longname
= "Remote serial target in ES1800-emulator protocol";
1977 es1800_ops
.to_doc
= "Remote debugging on the es1800 emulator via a serial line.\n\
1978 Specify the serial device it is connected to (e.g. /dev/ttya).";
1979 es1800_ops
.to_open
= es1800_open
;
1980 es1800_ops
.to_close
= es1800_close
;
1981 es1800_ops
.to_attach
= es1800_attach
;
1982 es1800_ops
.to_post_attach
= NULL
;
1983 es1800_ops
.to_require_attach
= NULL
;
1984 es1800_ops
.to_detach
= es1800_detach
;
1985 es1800_ops
.to_require_detach
= NULL
;
1986 es1800_ops
.to_resume
= es1800_resume
;
1987 es1800_ops
.to_wait
= NULL
;
1988 es1800_ops
.to_post_wait
= NULL
;
1989 es1800_ops
.to_fetch_registers
= NULL
;
1990 es1800_ops
.to_store_registers
= NULL
;
1991 es1800_ops
.to_prepare_to_store
= es1800_prepare_to_store
;
1992 es1800_ops
.to_xfer_memory
= es1800_xfer_inferior_memory
;
1993 es1800_ops
.to_files_info
= es1800_files_info
;
1994 es1800_ops
.to_insert_breakpoint
= es1800_insert_breakpoint
;
1995 es1800_ops
.to_remove_breakpoint
= es1800_remove_breakpoint
;
1996 es1800_ops
.to_terminal_init
= NULL
;
1997 es1800_ops
.to_terminal_inferior
= NULL
;
1998 es1800_ops
.to_terminal_ours_for_output
= NULL
;
1999 es1800_ops
.to_terminal_ours
= NULL
;
2000 es1800_ops
.to_terminal_info
= NULL
;
2001 es1800_ops
.to_kill
= NULL
;
2002 es1800_ops
.to_load
= es1800_load
;
2003 es1800_ops
.to_lookup_symbol
= NULL
;
2004 es1800_ops
.to_create_inferior
= es1800_create_inferior
;
2005 es1800_ops
.to_post_startup_inferior
= NULL
;
2006 es1800_ops
.to_acknowledge_created_inferior
= NULL
;
2007 es1800_ops
.to_clone_and_follow_inferior
= NULL
;
2008 es1800_ops
.to_post_follow_inferior_by_clone
= NULL
;
2009 es1800_ops
.to_insert_fork_catchpoint
= NULL
;
2010 es1800_ops
.to_remove_fork_catchpoint
= NULL
;
2011 es1800_ops
.to_insert_vfork_catchpoint
= NULL
;
2012 es1800_ops
.to_remove_vfork_catchpoint
= NULL
;
2013 es1800_ops
.to_has_forked
= NULL
;
2014 es1800_ops
.to_has_vforked
= NULL
;
2015 es1800_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2016 es1800_ops
.to_post_follow_vfork
= NULL
;
2017 es1800_ops
.to_insert_exec_catchpoint
= NULL
;
2018 es1800_ops
.to_remove_exec_catchpoint
= NULL
;
2019 es1800_ops
.to_has_execd
= NULL
;
2020 es1800_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2021 es1800_ops
.to_has_exited
= NULL
;
2022 es1800_ops
.to_mourn_inferior
= NULL
;
2023 es1800_ops
.to_can_run
= 0;
2024 es1800_ops
.to_notice_signals
= 0;
2025 es1800_ops
.to_thread_alive
= 0;
2026 es1800_ops
.to_stop
= 0;
2027 es1800_ops
.to_pid_to_exec_file
= NULL
;
2028 es1800_ops
.to_core_file_to_sym_file
= NULL
;
2029 es1800_ops
.to_stratum
= core_stratum
;
2030 es1800_ops
.DONT_USE
= 0;
2031 es1800_ops
.to_has_all_memory
= 0;
2032 es1800_ops
.to_has_memory
= 1;
2033 es1800_ops
.to_has_stack
= 0;
2034 es1800_ops
.to_has_registers
= 0;
2035 es1800_ops
.to_has_execution
= 0;
2036 es1800_ops
.to_sections
= NULL
;
2037 es1800_ops
.to_sections_end
= NULL
;
2038 es1800_ops
.to_magic
= OPS_MAGIC
;
2041 /* Define the target subroutine names */
2043 struct target_ops es1800_child_ops
;
2046 init_es1800_child_ops (void)
2048 es1800_child_ops
.to_shortname
= "es1800_process";
2049 es1800_child_ops
.to_longname
= "Remote serial target in ES1800-emulator protocol";
2050 es1800_child_ops
.to_doc
= "Remote debugging on the es1800 emulator via a serial line.\n\
2051 Specify the serial device it is connected to (e.g. /dev/ttya).";
2052 es1800_child_ops
.to_open
= es1800_child_open
;
2053 es1800_child_ops
.to_close
= NULL
;
2054 es1800_child_ops
.to_attach
= es1800_attach
;
2055 es1800_child_ops
.to_post_attach
= NULL
;
2056 es1800_child_ops
.to_require_attach
= NULL
;
2057 es1800_child_ops
.to_detach
= es1800_child_detach
;
2058 es1800_child_ops
.to_require_detach
= NULL
;
2059 es1800_child_ops
.to_resume
= es1800_resume
;
2060 es1800_child_ops
.to_wait
= es1800_wait
;
2061 es1800_child_ops
.to_post_wait
= NULL
;
2062 es1800_child_ops
.to_fetch_registers
= es1800_fetch_register
;
2063 es1800_child_ops
.to_store_registers
= es1800_store_register
;
2064 es1800_child_ops
.to_prepare_to_store
= es1800_prepare_to_store
;
2065 es1800_child_ops
.to_xfer_memory
= es1800_xfer_inferior_memory
;
2066 es1800_child_ops
.to_files_info
= es1800_files_info
;
2067 es1800_child_ops
.to_insert_breakpoint
= es1800_insert_breakpoint
;
2068 es1800_child_ops
.to_remove_breakpoint
= es1800_remove_breakpoint
;
2069 es1800_child_ops
.to_terminal_init
= NULL
;
2070 es1800_child_ops
.to_terminal_inferior
= NULL
;
2071 es1800_child_ops
.to_terminal_ours_for_output
= NULL
;
2072 es1800_child_ops
.to_terminal_ours
= NULL
;
2073 es1800_child_ops
.to_terminal_info
= NULL
;
2074 es1800_child_ops
.to_kill
= es1800_kill
;
2075 es1800_child_ops
.to_load
= es1800_load
;
2076 es1800_child_ops
.to_lookup_symbol
= NULL
;
2077 es1800_child_ops
.to_create_inferior
= es1800_create_inferior
;
2078 es1800_child_ops
.to_post_startup_inferior
= NULL
;
2079 es1800_child_ops
.to_acknowledge_created_inferior
= NULL
;
2080 es1800_child_ops
.to_clone_and_follow_inferior
= NULL
;
2081 es1800_child_ops
.to_post_follow_inferior_by_clone
= NULL
;
2082 es1800_child_ops
.to_insert_fork_catchpoint
= NULL
;
2083 es1800_child_ops
.to_remove_fork_catchpoint
= NULL
;
2084 es1800_child_ops
.to_insert_vfork_catchpoint
= NULL
;
2085 es1800_child_ops
.to_remove_vfork_catchpoint
= NULL
;
2086 es1800_child_ops
.to_has_forked
= NULL
;
2087 es1800_child_ops
.to_has_vforked
= NULL
;
2088 es1800_child_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2089 es1800_child_ops
.to_post_follow_vfork
= NULL
;
2090 es1800_child_ops
.to_insert_exec_catchpoint
= NULL
;
2091 es1800_child_ops
.to_remove_exec_catchpoint
= NULL
;
2092 es1800_child_ops
.to_has_execd
= NULL
;
2093 es1800_child_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2094 es1800_child_ops
.to_has_exited
= NULL
;
2095 es1800_child_ops
.to_mourn_inferior
= es1800_mourn_inferior
;
2096 es1800_child_ops
.to_can_run
= 0;
2097 es1800_child_ops
.to_notice_signals
= 0;
2098 es1800_child_ops
.to_thread_alive
= 0;
2099 es1800_child_ops
.to_stop
= 0;
2100 es1800_child_ops
.to_pid_to_exec_file
= NULL
;
2101 es1800_child_ops
.to_core_file_to_sym_file
= NULL
;
2102 es1800_child_ops
.to_stratum
= process_stratum
;
2103 es1800_child_ops
.DONT_USE
= 0;
2104 es1800_child_ops
.to_has_all_memory
= 1;
2105 es1800_child_ops
.to_has_memory
= 1;
2106 es1800_child_ops
.to_has_stack
= 1;
2107 es1800_child_ops
.to_has_registers
= 1;
2108 es1800_child_ops
.to_has_execution
= 1;
2109 es1800_child_ops
.to_sections
= NULL
;
2110 es1800_child_ops
.to_sections_end
= NULL
;
2111 es1800_child_ops
.to_magic
= OPS_MAGIC
;
2115 _initialize_es1800 (void)
2118 init_es1800_child_ops ();
2119 add_target (&es1800_ops
);
2120 add_target (&es1800_child_ops
);
2121 #ifdef PROVIDE_TRANSPARENT
2122 add_com ("transparent", class_support
, es1800_transparent
,
2123 "Start transparent communication with the ES 1800 emulator.");
2124 #endif /* PROVIDE_TRANSPARENT */
2125 add_com ("init_break", class_support
, es1800_init_break
,
2126 "Download break routine and initialize break facility on ES 1800");