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"
113 /* Prototypes for local functions */
115 static void es1800_child_detach (char *, int);
117 static void es1800_child_open (char *, int);
119 static void es1800_transparent (char *, int);
121 static void es1800_create_inferior (char *, char *, char **);
123 static void es1800_load (char *, int);
125 static void es1800_kill (void);
127 static int verify_break (int);
129 static int es1800_remove_breakpoint (CORE_ADDR
, char *);
131 static int es1800_insert_breakpoint (CORE_ADDR
, char *);
133 static void es1800_files_info (struct target_ops
*);
136 es1800_xfer_inferior_memory (CORE_ADDR
, char *, int, int,
137 struct mem_attrib
*, struct target_ops
*);
139 static void es1800_prepare_to_store (void);
141 static int es1800_wait (int, struct target_waitstatus
*);
143 static void es1800_resume (int, int, enum target_signal
);
145 static void es1800_detach (char *, int);
147 static void es1800_attach (char *, int);
149 static int damn_b (char *);
151 static void es1800_open (char *, int);
153 static void es1800_timer (void);
155 static void es1800_reset (char *);
157 static void es1800_request_quit (void);
159 static int readchar (void);
161 static void expect (char *, int);
163 static void expect_prompt (void);
165 static void download (FILE *, int, int);
168 static void bfd_copy (bfd
*, bfd
*);
171 static void get_break_addr (int, CORE_ADDR
*);
173 static int fromhex (int);
175 static int tohex (int);
177 static void es1800_close (int);
179 static void es1800_fetch_registers (void);
181 static void es1800_fetch_register (int);
183 static void es1800_store_register (int);
185 static void es1800_read_bytes (CORE_ADDR
, char *, int);
187 static void es1800_write_bytes (CORE_ADDR
, char *, int);
189 static void send_with_reply (char *, char *, int);
191 static void send_command (char *);
193 static void send (char *);
195 static void getmessage (char *, int);
197 static void es1800_mourn_inferior (void);
199 static void es1800_create_break_insn (char *, int);
201 static void es1800_init_break (char *, int);
203 /* Local variables */
205 /* FIXME: Convert this to use "set remotedebug" instead. */
206 #define LOG_FILE "es1800.log"
207 #if defined (LOG_FILE)
208 static FILE *log_file
;
211 extern struct target_ops es1800_ops
; /* Forward decl */
212 extern struct target_ops es1800_child_ops
; /* Forward decl */
215 static int timeout
= 100;
216 static char *savename
; /* Name of i/o device used */
217 static serial_ttystate es1800_saved_ttystate
;
218 static int es1800_fc_save
; /* Save fcntl state */
220 /* indicates that the emulator uses 32-bit data-adress (68020-mode)
221 instead of 24-bit (68000 -mode) */
225 #define MODE (m68020 ? "M68020" : "M68000" )
226 #define ES1800_BREAK_VEC (0xf)
228 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
229 es1800_open knows that we don't have a file open when the program
232 static serial_t es1800_desc
= NULL
;
235 #define HDRLEN sizeof("@.BAAAAAAAA=$VV\r")
237 /* Maximum number of bytes to read/write at once. The value here
238 is chosen to fill up a packet. */
240 #define MAXBUFBYTES ((PBUFSIZ-150)*16/75 )
242 static int es1800_break_vec
= 0;
243 static char es1800_break_insn
[2];
244 static long es1800_break_address
;
245 static void (*old_sigint
) (); /* Old signal-handler for sigint */
246 static jmp_buf interrupt
;
248 /* Local signalhandler to allow breaking tranfers or program run.
249 Rely on global variables: old_sigint(), interrupt */
252 es1800_request_quit (void)
254 /* restore original signalhandler */
255 signal (SIGINT
, old_sigint
);
256 longjmp (interrupt
, 1);
261 Sending reset character(octal 32) to emulator.
262 quit - return to '(esgdb)' prompt or continue */
265 es1800_reset (char *quit
)
271 printf ("\nResetting emulator... ");
273 strcpy (buf
, "\032");
283 /* Open a connection to a remote debugger and push the new target
284 onto the stack. Check if the emulator is responding and find out
285 what kind of processor the emulator is connected to.
286 Initiate the breakpoint handling in the emulator.
288 name - the filename used for communication (ex. '/dev/tta')
289 from_tty - says whether to be verbose or not */
292 es1800_open (char *name
, int from_tty
)
300 if (!name
) /* no device name given in target command */
302 error_no_arg ("serial port device name");
305 target_preopen (from_tty
);
308 /* open the device and configure it for communication */
312 es1800_desc
= SERIAL_OPEN (name
);
313 if (es1800_desc
== NULL
)
315 perror_with_name (name
);
317 savename
= savestring (name
, strlen (name
));
319 es1800_saved_ttystate
= SERIAL_GET_TTY_STATE (es1800_desc
);
321 if ((fcflag
= fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_GETFL
, 0)) == -1)
323 perror_with_name ("fcntl serial");
325 es1800_fc_save
= fcflag
;
327 fcflag
= (fcflag
& (FREAD
| FWRITE
)); /* mask out any funny stuff */
328 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, fcflag
) == -1)
330 perror_with_name ("fcntl serial");
335 if (SERIAL_SETBAUDRATE (es1800_desc
, baud_rate
))
337 SERIAL_CLOSE (es1800_desc
);
338 perror_with_name (name
);
342 SERIAL_RAW (es1800_desc
);
344 /* If there is something sitting in the buffer we might take it as a
345 response to a command, which would be bad. */
346 SERIAL_FLUSH_INPUT (es1800_desc
);
348 #endif /* DEBUG_STDIN */
350 push_target (&es1800_ops
); /* Switch to using remote target now */
353 printf ("Remote ES1800 debugging using %s\n", name
);
356 #if defined (LOG_FILE)
358 log_file
= fopen (LOG_FILE
, "w");
359 if (log_file
== NULL
)
361 perror_with_name (LOG_FILE
);
364 #endif /* LOG_FILE */
366 /* Hello? Are you there?, also check mode */
368 /* send_with_reply( "DB 0 TO 1", buf, sizeof(buf)); */
369 /* for (p = buf, i = 0; *p++ =='0';) *//* count the number of zeros */
373 getmessage (buf
, sizeof (buf
)); /* send reset character */
377 printf ("Checking mode.... ");
379 /* m68020 = (i==8); *//* if eight zeros then we are in m68020 mode */
381 /* What kind of processor am i talking to ? */
392 for (i
= 0; i
< 20; i
++, p
++)
395 m68020
= !strncmp (p
, "68020", 5);
398 printf ("You are in %s(%c%c%c%c%c)-mode\n", MODE
, p
[0], p
[1], p
[2],
402 /* if no init_break statement is present in .gdb file we have to check
403 whether to download a breakpoint routine or not */
406 if ((es1800_break_vec
== 0) || (verify_break (es1800_break_vec
) != 0)
407 && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
409 CORE_ADDR memaddress
;
410 printf ("Give the start address of the breakpoint routine: ");
411 scanf ("%li", &memaddress
);
412 es1800_init_break ((es1800_break_vec
? es1800_break_vec
:
413 ES1800_BREAK_VEC
), memaddress
);
419 /* Close out all files and local state before this target loses control.
420 quitting - are we quitting gdb now? */
423 es1800_close (int quitting
)
425 if (es1800_desc
!= NULL
)
427 printf ("\nClosing connection to emulator...\n");
428 if (SERIAL_SET_TTY_STATE (es1800_desc
, es1800_saved_ttystate
) < 0)
429 print_sys_errmsg ("warning: unable to restore tty state", errno
);
430 fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, es1800_fc_save
);
431 SERIAL_CLOSE (es1800_desc
);
434 if (savename
!= NULL
)
440 #if defined (LOG_FILE)
442 if (log_file
!= NULL
)
444 if (ferror (log_file
))
446 printf ("Error writing log file.\n");
448 if (fclose (log_file
) != 0)
450 printf ("Error closing log file.\n");
455 #endif /* LOG_FILE */
459 /* Attaches to a process on the target side
460 proc_id - the id of the process to be attached.
461 from_tty - says whether to be verbose or not */
464 es1800_attach (char *args
, int from_tty
)
466 error ("Cannot attach to pid %s, this feature is not implemented yet.",
471 /* Takes a program previously attached to and detaches it.
472 We better not have left any breakpoints
473 in the program or it'll die when it hits one.
474 Close the open connection to the remote debugger.
475 Use this when you want to detach and do something else
478 args - arguments given to the 'detach' command
479 from_tty - says whether to be verbose or not */
482 es1800_detach (char *args
, int from_tty
)
486 error ("Argument given to \"detach\" when remotely debugging.");
491 printf ("Ending es1800 remote debugging.\n");
496 /* Tell the remote machine to resume.
497 step - single-step or run free
498 siggnal - the signal value to be given to the target (0 = no signal) */
501 es1800_resume (int pid
, int step
, enum target_signal siggnal
)
507 error ("Can't send signals to a remote system.");
511 strcpy (buf
, "STP\r");
516 send_command ("RBK");
520 /* Wait until the remote machine stops, then return,
521 storing status in STATUS just as `wait' would.
525 es1800_wait (int pid
, struct target_waitstatus
*status
)
527 unsigned char buf
[PBUFSIZ
];
528 int old_timeout
= timeout
;
530 status
->kind
= TARGET_WAITKIND_EXITED
;
531 status
->value
.integer
= 0;
533 timeout
= 0; /* Don't time out -- user program is running. */
534 if (!setjmp (interrupt
))
536 old_sigint
= signal (SIGINT
, es1800_request_quit
);
539 getmessage (buf
, sizeof (buf
));
540 if (strncmp (buf
, "\r\n* BREAK *", 11) == 0)
542 status
->kind
= TARGET_WAITKIND_STOPPED
;
543 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
544 send_command ("STP"); /* Restore stack and PC and such */
547 send_command ("STP");
551 if (strncmp (buf
, "STP\r\n ", 6) == 0)
553 status
->kind
= TARGET_WAITKIND_STOPPED
;
554 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
557 if (buf
[strlen (buf
) - 2] == 'R')
559 printf ("Unexpected emulator reply: \n%s\n", buf
);
563 printf ("Unexpected stop: \n%s\n", buf
);
564 status
->kind
= TARGET_WAITKIND_STOPPED
;
565 status
->value
.sig
= TARGET_SIGNAL_QUIT
;
573 printf ("\nStopping emulator...");
574 if (!setjmp (interrupt
))
576 old_sigint
= signal (SIGINT
, es1800_request_quit
);
577 send_command ("STP");
578 printf (" emulator stopped\n");
579 status
->kind
= TARGET_WAITKIND_STOPPED
;
580 status
->value
.sig
= TARGET_SIGNAL_INT
;
585 es1800_reset ((char *) 1);
588 signal (SIGINT
, old_sigint
);
589 timeout
= old_timeout
;
594 /* Fetch register values from remote machine.
595 regno - the register to be fetched (fetch all registers if -1) */
598 es1800_fetch_register (int regno
)
604 static char regtab
[18][4] =
606 "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
607 "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
611 if ((regno
< 15) || (regno
== 16) || (regno
== 17))
614 send_with_reply (regtab
[regno
], buf
, sizeof (buf
));
616 for (k
= 0; k
< 4; k
++)
618 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
620 error ("Emulator reply is too short: %s", buf
);
622 registers
[r
++] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
627 es1800_fetch_registers ();
631 /* Read the remote registers into REGISTERS.
632 Always fetches all registers. */
635 es1800_fetch_registers (void)
638 char SR_buf
[PBUFSIZ
];
644 send_with_reply ("DR", buf
, sizeof (buf
));
646 /* Reply is edited to a string that describes registers byte by byte,
647 each byte encoded as two hex characters. */
652 /* parsing row one - D0-D7-registers */
657 for (i
= 4; i
< 70; i
+= (i
== 39 ? 3 : 1))
659 for (k
= 0; k
< 4; k
++)
661 if (p
[i
+ 0] == 0 || p
[i
+ 1] == 0)
663 error ("Emulator reply is too short: %s", buf
);
665 registers
[r
++] = (fromhex (p
[i
+ 0]) * 16) + fromhex (p
[i
+ 1]);
671 /* parsing row two - A0-A6-registers */
676 for (i
= 4; i
< 61; i
+= (i
== 39 ? 3 : 1))
678 for (k
= 0; k
< 4; k
++)
680 if (p
[i
+ 0] == 0 || p
[i
+ 1] == 0)
682 error ("Emulator reply is too short: %s", buf
);
684 registers
[r
++] = (fromhex (p
[i
+ 0])) * 16 + fromhex (p
[i
+ 1]);
694 /* fetch SSP-, SR- and PC-registers */
696 /* first - check STATUS-word and decide which stackpointer to use */
698 send_with_reply ("SR", SR_buf
, sizeof (SR_buf
));
704 if (*p
== '3') /* use masterstackpointer MSP */
706 send_with_reply ("MSP", buf
, sizeof (buf
));
708 else if (*p
== '2') /* use interruptstackpointer ISP */
710 send_with_reply ("ISP", buf
, sizeof (buf
));
713 /* use userstackpointer USP */
715 send_with_reply ("USP", buf
, sizeof (buf
));
718 for (k
= 0; k
< 4; k
++)
720 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
722 error ("Emulator reply is too short: %s", buf
);
724 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
728 for (k
= 0; k
< 4; k
++)
730 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
732 error ("Emulator reply is too short: %s", buf
);
735 fromhex (SR_buf
[k
* 2 + 1]) * 16 + fromhex (SR_buf
[k
* 2 + 2]);
737 send_with_reply ("PC", buf
, sizeof (buf
));
739 for (k
= 0; k
< 4; k
++)
741 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
743 error ("Emulator reply is too short: %s", buf
);
745 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
751 if (*p
== '2') /* use supervisorstackpointer SSP */
753 send_with_reply ("SSP", buf
, sizeof (buf
));
756 /* use userstackpointer USP */
758 send_with_reply ("USP", buf
, sizeof (buf
));
761 /* fetch STACKPOINTER */
764 for (k
= 0; k
< 4; k
++)
766 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
768 error ("Emulator reply is too short: %s", buf
);
770 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
776 for (k
= 0; k
< 4; k
++)
778 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
780 error ("Emulator reply is too short: %s", buf
);
783 fromhex (SR_buf
[k
* 2 + 1]) * 16 + fromhex (SR_buf
[k
* 2 + 2]);
788 send_with_reply ("PC", buf
, sizeof (buf
));
790 for (k
= 0; k
< 4; k
++)
792 if (p
[k
* 2 + 1] == 0 || p
[k
* 2 + 2] == 0)
794 error ("Emulator reply is too short: %s", buf
);
796 registers
[r
++] = fromhex (buf
[k
* 2 + 1]) * 16 + fromhex (buf
[k
* 2 + 2]);
801 /* Store register value, located in REGISTER, on the target processor.
802 regno - the register-number of the register to store
803 (-1 means store them all)
804 FIXME: Return errno value. */
807 es1800_store_register (int regno
)
810 static char regtab
[18][4] =
812 "D0 ", "D1 ", "D2 ", "D3 ", "D4 ", "D5 ", "D6 ", "D7 ",
813 "A0 ", "A1 ", "A2 ", "A3 ", "A4 ", "A5 ", "A6 ", "SSP",
818 char SR_buf
[PBUFSIZ
];
819 char stack_pointer
[4];
826 r
= (unsigned char *) registers
;
828 if (regno
== -1) /* write all registers */
834 /* write one register */
841 if ((regno
== -1) || (regno
== 15))
843 /* fetch current status */
844 send_with_reply ("SR", SR_buf
, sizeof (SR_buf
));
849 if (*p
== '3') /* use masterstackpointer MSP */
851 strcpy (stack_pointer
, "MSP");
855 if (*p
== '2') /* use interruptstackpointer ISP */
857 strcpy (stack_pointer
, "ISP");
861 strcpy (stack_pointer
, "USP"); /* use userstackpointer USP */
868 if (*p
== '2') /* use supervisorstackpointer SSP */
870 strcpy (stack_pointer
, "SSP");
874 strcpy (stack_pointer
, "USP"); /* use userstackpointer USP */
877 strcpy (regtab
[15], stack_pointer
);
880 for (i
= j
; i
< k
; i
++)
882 buf
[0] = regtab
[i
][0];
883 buf
[1] = regtab
[i
][1];
884 buf
[2] = regtab
[i
][2];
887 buf
[5] = tohex ((*r
>> 4) & 0x0f);
888 buf
[6] = tohex (*r
++ & 0x0f);
889 buf
[7] = tohex ((*r
>> 4) & 0x0f);
890 buf
[8] = tohex (*r
++ & 0x0f);
891 buf
[9] = tohex ((*r
>> 4) & 0x0f);
892 buf
[10] = tohex (*r
++ & 0x0f);
893 buf
[11] = tohex ((*r
>> 4) & 0x0f);
894 buf
[12] = tohex (*r
++ & 0x0f);
897 send_with_reply (buf
, buf
, sizeof (buf
)); /* FIXME, reply not used? */
902 /* Prepare to store registers. */
905 es1800_prepare_to_store (void)
907 /* Do nothing, since we can store individual regs */
910 /* Convert hex digit A to a number. */
915 if (a
>= '0' && a
<= '9')
919 else if (a
>= 'a' && a
<= 'f')
923 else if (a
>= 'A' && a
<= 'F')
929 error ("Reply contains invalid hex digit");
935 /* Convert number NIB to a hex digit. */
946 return ('A' + nib
- 10);
950 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
951 to or from debugger address MYADDR. Write to inferior if WRITE is
952 nonzero. Returns length of data written or read; 0 for error.
954 memaddr - the target's address
955 myaddr - gdb's address
956 len - number of bytes
957 write - write if != 0 otherwise read
961 es1800_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
963 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
964 struct target_ops
*target ATTRIBUTE_UNUSED
)
971 xfersize
= len
> MAXBUFBYTES
? MAXBUFBYTES
: len
;
974 es1800_write_bytes (memaddr
, myaddr
, xfersize
);
978 es1800_read_bytes (memaddr
, myaddr
, xfersize
);
984 return (origlen
); /* no error possible */
988 /* Write memory data directly to the emulator.
989 This does not inform the data cache; the data cache uses this.
990 MEMADDR is the address in the remote memory space.
991 MYADDR is the address of the buffer in our space.
992 LEN is the number of bytes.
994 memaddr - the target's address
995 myaddr - gdb's address
996 len - number of bytes */
999 es1800_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1006 for (i
= 0; i
< len
; i
++)
1008 sprintf (buf
, "@.B$%x=$%x", memaddr
+ i
, (*p
++) & 0xff);
1009 send_with_reply (buf
, buf
, sizeof (buf
)); /* FIXME send_command? */
1014 /* Read memory data directly from the emulator.
1015 This does not use the data cache; the data cache uses this.
1017 memaddr - the target's address
1018 myaddr - gdb's address
1019 len - number of bytes */
1022 es1800_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
1024 static int DB_tab
[16] =
1025 {8, 11, 14, 17, 20, 23, 26, 29, 34, 37, 40, 43, 46, 49, 52, 55};
1032 if (len
> PBUFSIZ
/ 2 - 1)
1037 if (len
== 1) /* The emulator does not like expressions like: */
1039 len
= 2; /* DB.B $20018 TO $20018 */
1042 /* Reply describes registers byte by byte, each byte encoded as two hex
1045 sprintf (buf
, "DB.B $%x TO $%x", memaddr
, memaddr
+ len
- 1);
1046 send_with_reply (buf
, buf
, sizeof (buf
));
1048 low_addr
= memaddr
& 0x0f;
1049 for (i
= low_addr
; i
< low_addr
+ len
; i
++)
1051 if ((!(i
% 16)) && i
)
1052 { /* if (i = 16,32,48) */
1053 while (*p
++ != '\n')
1058 p
= b
+ DB_tab
[i
% 16] + (m68020
? 2 : 0);
1059 if (p
[0] == 32 || p
[1] == 32)
1061 error ("Emulator reply is too short: %s", buf
);
1063 myaddr
[i
- low_addr
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1067 /* Display information about the current target. TOPS is unused. */
1070 es1800_files_info (struct target_ops
*tops
)
1072 printf ("ES1800 Attached to %s at %d baud in %s mode\n", savename
, 19200,
1077 /* We read the contents of the target location and stash it,
1078 then overwrite it with a breakpoint instruction.
1080 addr - is the target location in the target machine.
1081 contents_cache - is a pointer to memory allocated for saving the target contents.
1082 It is guaranteed by the caller to be long enough to save sizeof
1085 FIXME: This size is target_arch dependent and should be available in
1086 the target_arch transfer vector, if we ever have one... */
1089 es1800_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1093 val
= target_read_memory (addr
, contents_cache
, sizeof (es1800_break_insn
));
1097 val
= target_write_memory (addr
, es1800_break_insn
,
1098 sizeof (es1800_break_insn
));
1105 /* Write back the stashed instruction
1107 addr - is the target location in the target machine.
1108 contents_cache - is a pointer to memory allocated for saving the target contents.
1109 It is guaranteed by the caller to be long enough to save sizeof
1110 BREAKPOINT bytes. */
1113 es1800_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1116 return (target_write_memory (addr
, contents_cache
,
1117 sizeof (es1800_break_insn
)));
1120 /* create_break_insn ()
1121 Primitive datastructures containing the es1800 breakpoint instruction */
1124 es1800_create_break_insn (char *ins
, int vec
)
1135 Seach for breakpoint routine in emulator memory.
1136 returns non-zero on failure
1137 vec - trap vector used for breakpoints */
1140 verify_break (int vec
)
1142 CORE_ADDR memaddress
;
1144 char *instr
= "NqNqNqNs"; /* breakpoint routine */
1147 get_break_addr (vec
, &memaddress
);
1151 status
= target_read_memory (memaddress
, buf
, 8);
1154 memory_error (status
, memaddress
);
1156 return (strcmp (instr
, buf
));
1162 /* get_break_addr ()
1163 find address of breakpoint routine
1164 vec - trap vector used for breakpoints
1165 addrp - store the address here */
1168 get_break_addr (int vec
, CORE_ADDR
*addrp
)
1170 CORE_ADDR memaddress
= 0;
1179 send_with_reply ("VBR ", buf
, sizeof (buf
));
1181 for (k
= 0; k
< 4; k
++)
1183 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
1185 error ("Emulator reply is too short: %s", buf
);
1187 base_addr
[k
] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
1189 /* base addr of exception vector table */
1190 memaddress
= *((CORE_ADDR
*) base_addr
);
1193 memaddress
+= (vec
+ 32) * 4; /* address of trap vector */
1194 status
= target_read_memory (memaddress
, (char *) addrp
, 4);
1197 memory_error (status
, memaddress
);
1202 /* Kill an inferior process */
1207 if (inferior_pid
!= 0)
1210 es1800_mourn_inferior ();
1215 /* Load a file to the ES1800 emulator.
1216 Converts the file from a.out format into Extended Tekhex format
1217 before the file is loaded.
1218 Also loads the trap routine, and sets the ES1800 breakpoint on it
1219 filename - the a.out to be loaded
1220 from_tty - says whether to be verbose or not
1221 FIXME Uses emulator overlay memory for trap routine */
1224 es1800_load (char *filename
, int from_tty
)
1230 struct cleanup
*old_chain
;
1231 int es1800_load_format
= 5;
1233 if (es1800_desc
== NULL
)
1235 printf ("No emulator attached, type emulator-command first\n");
1239 filename
= tilde_expand (filename
);
1240 make_cleanup (xfree
, filename
);
1242 switch (es1800_load_format
)
1244 case 2: /* Extended Tekhex */
1247 printf ("Converting \"%s\" to Extended Tekhex Format\n", filename
);
1249 sprintf (buf
, "tekhex %s", filename
);
1251 sprintf (loadname
, "out.hex");
1254 case 5: /* Motorola S-rec */
1257 printf ("Converting \"%s\" to Motorola S-record format\n",
1260 /* in the future the source code in copy (part of binutils-1.93) will
1261 be included in this file */
1263 "copy -s \"a.out-sunos-big\" -d \"srec\" %s /tmp/out.hex",
1266 sprintf (loadname
, "/tmp/out.hex");
1270 error ("Downloading format not defined\n");
1273 breakpoint_init_inferior ();
1277 printf ("Downloading \"%s\" to the ES 1800\n", filename
);
1279 if ((instream
= fopen (loadname
, "r")) == NULL
)
1281 perror_with_name ("fopen:");
1284 old_chain
= make_cleanup (fclose
, instream
);
1289 download (instream
, from_tty
, es1800_load_format
);
1291 /* if breakpoint routine is not present anymore we have to check
1292 whether to download a new breakpoint routine or not */
1294 if ((verify_break (es1800_break_vec
) != 0)
1295 && query ("No breakpoint routine in ES 1800 emulator!\nDownload a breakpoint routine to the emulator? "))
1298 printf ("Using break vector 0x%x\n", es1800_break_vec
);
1299 sprintf (buf
, "0x%x ", es1800_break_vec
);
1300 printf ("Give the start address of the breakpoint routine: ");
1301 fgets (buf
+ strlen (buf
), sizeof (buf
) - strlen (buf
), stdin
);
1302 es1800_init_break (buf
, 0);
1305 do_cleanups (old_chain
);
1307 readchar (); /* FIXME I am getting a ^G = 7 after the prompt */
1310 if (fclose (instream
) == EOF
)
1315 if (es1800_load_format
!= 2)
1317 sprintf (buf
, "/usr/bin/rm %s", loadname
);
1321 symbol_file_add_main (filename
, from_tty
); /* reading symbol table */
1327 #define NUMCPYBYTES 20
1330 bfd_copy (bfd
*from_bfd
, bfd
*to_bfd
)
1334 char buf
[NUMCPYBYTES
];
1336 for (p
= from_bfd
->sections
; p
!= NULL
; p
= p
->next
)
1338 printf (" Copying section %s. Size = %x.\n", p
->name
, p
->_cooked_size
);
1339 printf (" vma = %x, offset = %x, output_sec = %x\n",
1340 p
->vma
, p
->output_offset
, p
->output_section
);
1341 new = bfd_make_section (to_bfd
, p
->name
);
1342 if (p
->_cooked_size
&&
1343 !bfd_set_section_size (to_bfd
, new, p
->_cooked_size
))
1345 error ("Wrong BFD size!\n");
1347 if (!bfd_set_section_flags (to_bfd
, new, p
->flags
))
1349 error ("bfd_set_section_flags");
1353 for (i
= 0; (i
+ NUMCPYBYTES
) < p
->_cooked_size
; i
+= NUMCPYBYTES
)
1355 if (!bfd_get_section_contents (from_bfd
, p
, (PTR
) buf
, (file_ptr
) i
,
1356 (bfd_size_type
) NUMCPYBYTES
))
1358 error ("bfd_get_section_contents\n");
1360 if (!bfd_set_section_contents (to_bfd
, new, (PTR
) buf
, (file_ptr
) i
,
1361 (bfd_size_type
) NUMCPYBYTES
))
1363 error ("bfd_set_section_contents\n");
1366 bfd_get_section_contents (from_bfd
, p
, (PTR
) buf
, (file_ptr
) i
,
1367 (bfd_size_type
) (p
->_cooked_size
- i
));
1368 bfd_set_section_contents (to_bfd
, new, (PTR
) buf
, (file_ptr
) i
,
1369 (bfd_size_type
) (p
->_cooked_size
- i
));
1375 /* Start an process on the es1800 and set inferior_pid to the new
1377 execfile - the file to run
1378 args - arguments passed to the program
1379 env - the environment vector to pass */
1382 es1800_create_inferior (char *execfile
, char *args
, char **env
)
1387 struct expression
*expr
;
1388 register struct cleanup
*old_chain
= 0;
1394 error ("Can't pass arguments to remote ES1800 process");
1398 if (query ("Use 'start' as entry point? "))
1400 expr
= parse_c_expression ("start");
1401 old_chain
= make_cleanup (free_current_contents
, &expr
);
1402 val
= evaluate_expression (expr
);
1403 entry_pt
= (val
->location
).address
;
1407 printf ("Enter the program's entry point (in hexadecimal): ");
1408 scanf ("%x", &entry_pt
);
1412 if (execfile
== 0 || exec_bfd
== 0)
1414 error ("No executable file specified");
1417 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
1421 /* Now that we have a child process, make it our target. */
1423 push_target (&es1800_child_ops
);
1425 /* The "process" (board) is already stopped awaiting our commands, and
1426 the program is already downloaded. We just set its PC and go. */
1428 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
1430 clear_proceed_status ();
1432 /* Tell wait_for_inferior that we've started a new process. */
1434 init_wait_for_inferior ();
1436 /* Set up the "saved terminal modes" of the inferior
1437 based on what modes we are starting it with. */
1439 target_terminal_init ();
1441 /* Install inferior's terminal modes. */
1443 target_terminal_inferior ();
1445 /* remote_start (args); */
1446 /* trap_expected = 0; */
1447 /* insert_step_breakpoint (); FIXME, do we need this? */
1449 /* Let 'er rip... */
1450 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
1455 /* The process has died, clean up. */
1458 es1800_mourn_inferior (void)
1460 remove_breakpoints ();
1461 unpush_target (&es1800_child_ops
);
1462 generic_mourn_inferior (); /* Do all the proper things now */
1465 /* ES1800-protocol specific routines */
1467 /* Keep discarding input from the remote system, until STRING is found.
1468 Let the user break out immediately.
1469 string - the string to expect
1470 nowait - break out if string not the emulator's first respond otherwise
1471 read until string is found (== 0) */
1474 expect (char *string
, int nowait
)
1487 if (c
== toupper (*p
))
1502 printf ("\'%s\' expected\n", string
);
1503 printf ("char %d is %d", p
- string
, c
);
1509 /* Keep discarding input until we see the prompt. */
1512 expect_prompt (void)
1518 /* Read one character */
1522 /* read from stdin */
1530 printf ("readchar, give one character\n");
1533 #if defined (LOG_FILE)
1534 putc (buf
[0] & 0x7f, log_file
);
1537 return (buf
[0] & 0x7f);
1540 #else /* !DEBUG_STDIN */
1542 /* Read a character from the remote system, doing all the fancy
1550 ch
= SERIAL_READCHAR (es1800_desc
, timeout
);
1552 /* FIXME: doing an error() here will probably cause trouble, at least if from
1554 if (ch
== SERIAL_TIMEOUT
)
1555 error ("Timeout reading from remote system.");
1556 else if (ch
== SERIAL_ERROR
)
1557 perror_with_name ("remote read");
1559 #if defined (LOG_FILE)
1560 putc (ch
& 0x7f, log_file
);
1567 #endif /* DEBUG_STDIN */
1570 /* Send a command to the emulator and save the reply.
1571 Report an error if we get an error reply.
1572 string - the es1800 command
1573 buf - containing the emulator reply on return
1574 len - size of buf */
1577 send_with_reply (char *string
, char *buf
, int len
)
1580 SERIAL_WRITE (es1800_desc
, "\r", 1);
1587 getmessage (buf
, len
);
1591 /* Send the command in STR to the emulator adding \r. check
1592 the echo for consistency.
1593 string - the es1800 command */
1596 send_command (char *string
)
1599 SERIAL_WRITE (es1800_desc
, "\r", 1);
1609 string - the es1800 command */
1616 fprintf (stderr
, "Sending: %s\n", string
);
1618 SERIAL_WRITE (es1800_desc
, string
, strlen (string
));
1622 /* Read a message from the emulator and store it in BUF.
1623 buf - containing the emulator reply on return
1624 len - size of buf */
1627 getmessage (char *buf
, int len
)
1631 int prompt_found
= 0;
1634 #if defined (LOG_FILE)
1635 /* This is a convenient place to do this. The idea is to do it often
1636 enough that we never lose much data if we terminate abnormally. */
1646 if (len
-- < 2) /* char and terminaling NULL */
1648 error ("input buffer overrun\n");
1653 if ((c
== '>') && (*(bp
- 1) == ' '))
1658 while (!prompt_found
);
1663 fprintf (stderr
, "message received :%s\n", buf
);
1668 download (FILE *instream
, int from_tty
, int format
)
1674 send_command ("SET #2,$1A"); /* reset char = ^Z */
1675 send_command ("SET #3,$11,$13"); /* XON XOFF */
1678 send_command ("SET #26,#2");
1682 send_command ("SET #26,#5"); /* Format=Extended Tekhex */
1684 send_command ("DFB = $10");
1685 send_command ("PUR");
1686 send_command ("CES");
1691 printf (" 0 records loaded...\r");
1693 while (fgets (buf
, 160, instream
))
1698 printf ("%5d\b\b\b\b\b", ++i
);
1701 if ((c
= readchar ()) != 006)
1703 error ("expected ACK");
1712 /* Additional commands */
1714 #if defined (TIOCGETP) && defined (FNDELAY) && defined (EWOULDBLOCK)
1715 #define PROVIDE_TRANSPARENT
1718 #ifdef PROVIDE_TRANSPARENT
1719 /* Talk directly to the emulator
1720 FIXME, uses busy wait, and is SUNOS (or at least BSD) specific */
1724 es1800_transparent (char *args
, int from_tty
)
1727 struct sgttyb modebl
;
1730 struct sgttyb console_mode_save
;
1731 int console_fc_save
;
1736 char consolebuf
[80];
1738 char es1800_buf
[80];
1742 if (es1800_desc
== NULL
)
1744 printf ("No emulator attached, type emulator-command first\n");
1749 printf ("You are now communicating directly with the ES 1800 emulator.\n");
1750 printf ("To leave this mode (transparent mode), press ^E.\n");
1755 if ((console
= open ("/dev/tty", O_RDWR
)) == -1)
1757 perror_with_name ("/dev/tty:");
1760 if ((fcflag
= fcntl (console
, F_GETFL
, 0)) == -1)
1762 perror_with_name ("fcntl console");
1765 console_fc_save
= fcflag
;
1766 fcflag
= fcflag
| FNDELAY
;
1768 if (fcntl (console
, F_SETFL
, fcflag
) == -1)
1770 perror_with_name ("fcntl console");
1773 if (ioctl (console
, TIOCGETP
, &modebl
))
1775 perror_with_name ("ioctl console");
1778 console_mode_save
= modebl
;
1779 modebl
.sg_flags
= RAW
;
1781 if (ioctl (console
, TIOCSETP
, &modebl
))
1783 perror_with_name ("ioctl console");
1786 if ((fcflag
= fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_GETFL
, 0)) == -1)
1788 perror_with_name ("fcntl serial");
1791 es1800_fc_save
= fcflag
;
1792 fcflag
= fcflag
| FNDELAY
;
1794 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, fcflag
) == -1)
1796 perror_with_name ("fcntl serial");
1801 cc
= read (console
, inputbuf
, inputcnt
);
1804 if ((*inputbuf
& 0x7f) == 0x05)
1808 for (i
= 0; i
< cc
;)
1810 es1800_buf
[es1800_cnt
++] = inputbuf
[i
++];
1812 if ((cc
= SERIAL_WRITE (es1800_desc
, es1800_buf
, es1800_cnt
)) == -1)
1814 perror_with_name ("FEL! write:");
1817 if (es1800_cnt
&& cc
)
1819 for (i
= 0; i
< es1800_cnt
; i
++)
1821 es1800_buf
[i
] = es1800_buf
[cc
+ i
];
1825 else if (errno
!= EWOULDBLOCK
)
1827 perror_with_name ("FEL! read:");
1830 cc
= read (DEPRECATED_SERIAL_FD (es1800_desc
), inputbuf
, inputcnt
);
1833 for (i
= 0; i
< cc
;)
1835 consolebuf
[consolecnt
++] = inputbuf
[i
++];
1837 if ((cc
= write (console
, consolebuf
, consolecnt
)) == -1)
1839 perror_with_name ("FEL! write:");
1842 if (consolecnt
&& cc
)
1844 for (i
= 0; i
< consolecnt
; i
++)
1846 consolebuf
[i
] = consolebuf
[cc
+ i
];
1850 else if (errno
!= EWOULDBLOCK
)
1852 perror_with_name ("FEL! read:");
1856 console_fc_save
= console_fc_save
& !FNDELAY
;
1857 if (fcntl (console
, F_SETFL
, console_fc_save
) == -1)
1859 perror_with_name ("FEL! fcntl");
1862 if (ioctl (console
, TIOCSETP
, &console_mode_save
))
1864 perror_with_name ("FEL! ioctl");
1869 if (fcntl (DEPRECATED_SERIAL_FD (es1800_desc
), F_SETFL
, es1800_fc_save
) == -1)
1871 perror_with_name ("FEL! fcntl");
1877 #endif /* PROVIDE_TRANSPARENT */
1880 es1800_init_break (char *args
, int from_tty
)
1882 CORE_ADDR memaddress
= 0;
1891 error_no_arg ("a trap vector");
1894 if (!(space_index
= strchr (args
, ' ')))
1896 error ("Two arguments needed (trap vector and address of break routine).\n");
1899 *space_index
= '\0';
1901 es1800_break_vec
= strtol (args
, (char **) NULL
, 0);
1902 es1800_break_address
= parse_and_eval_address (space_index
+ 1);
1904 es1800_create_break_insn (es1800_break_insn
, es1800_break_vec
);
1908 send_with_reply ("VBR ", buf
, sizeof (buf
));
1910 for (k
= 0; k
< 4; k
++)
1912 if ((p
[k
* 2 + 1] == 0) || (p
[k
* 2 + 2] == 0))
1914 error ("Emulator reply is too short: %s", buf
);
1916 base_addr
[k
] = (fromhex (p
[k
* 2 + 1]) * 16) + fromhex (p
[k
* 2 + 2]);
1918 /* base addr of exception vector table */
1919 memaddress
= *((CORE_ADDR
*) base_addr
);
1922 memaddress
+= (es1800_break_vec
+ 32) * 4; /* address of trap vector */
1924 sprintf (buf
, "@.L%lx=$%lx", memaddress
, es1800_break_address
);
1925 send_command (buf
); /* set the address of the break routine in the */
1928 sprintf (buf
, "@.L%lx=$4E714E71", es1800_break_address
); /* NOP; NOP */
1930 sprintf (buf
, "@.L%lx=$4E714E73", es1800_break_address
+ 4); /* NOP; RTE */
1933 sprintf (buf
, "AC2=$%lx", es1800_break_address
+ 4);
1934 /* breakpoint at es1800-break_address */
1936 send_command ("WHEN AC2 THEN BRK"); /* ie in exception routine */
1940 printf ("Breakpoint (trap $%x) routine at address: %lx\n",
1941 es1800_break_vec
, es1800_break_address
);
1946 es1800_child_open (char *arg
, int from_tty
)
1948 error ("Use the \"run\" command to start a child process.");
1952 es1800_child_detach (char *args
, int from_tty
)
1956 error ("Argument given to \"detach\" when remotely debugging.");
1962 printf ("Ending debugging the process %d.\n", inferior_pid
);
1967 /* Define the target subroutine names */
1969 struct target_ops es1800_ops
;
1972 init_es1800_ops (void)
1974 es1800_ops
.to_shortname
= "es1800";
1975 es1800_ops
.to_longname
= "Remote serial target in ES1800-emulator protocol";
1976 es1800_ops
.to_doc
= "Remote debugging on the es1800 emulator via a serial line.\n\
1977 Specify the serial device it is connected to (e.g. /dev/ttya).";
1978 es1800_ops
.to_open
= es1800_open
;
1979 es1800_ops
.to_close
= es1800_close
;
1980 es1800_ops
.to_attach
= es1800_attach
;
1981 es1800_ops
.to_post_attach
= NULL
;
1982 es1800_ops
.to_require_attach
= NULL
;
1983 es1800_ops
.to_detach
= es1800_detach
;
1984 es1800_ops
.to_require_detach
= NULL
;
1985 es1800_ops
.to_resume
= es1800_resume
;
1986 es1800_ops
.to_wait
= NULL
;
1987 es1800_ops
.to_post_wait
= NULL
;
1988 es1800_ops
.to_fetch_registers
= NULL
;
1989 es1800_ops
.to_store_registers
= NULL
;
1990 es1800_ops
.to_prepare_to_store
= es1800_prepare_to_store
;
1991 es1800_ops
.to_xfer_memory
= es1800_xfer_inferior_memory
;
1992 es1800_ops
.to_files_info
= es1800_files_info
;
1993 es1800_ops
.to_insert_breakpoint
= es1800_insert_breakpoint
;
1994 es1800_ops
.to_remove_breakpoint
= es1800_remove_breakpoint
;
1995 es1800_ops
.to_terminal_init
= NULL
;
1996 es1800_ops
.to_terminal_inferior
= NULL
;
1997 es1800_ops
.to_terminal_ours_for_output
= NULL
;
1998 es1800_ops
.to_terminal_ours
= NULL
;
1999 es1800_ops
.to_terminal_info
= NULL
;
2000 es1800_ops
.to_kill
= NULL
;
2001 es1800_ops
.to_load
= es1800_load
;
2002 es1800_ops
.to_lookup_symbol
= NULL
;
2003 es1800_ops
.to_create_inferior
= es1800_create_inferior
;
2004 es1800_ops
.to_post_startup_inferior
= NULL
;
2005 es1800_ops
.to_acknowledge_created_inferior
= NULL
;
2006 es1800_ops
.to_clone_and_follow_inferior
= NULL
;
2007 es1800_ops
.to_post_follow_inferior_by_clone
= NULL
;
2008 es1800_ops
.to_insert_fork_catchpoint
= NULL
;
2009 es1800_ops
.to_remove_fork_catchpoint
= NULL
;
2010 es1800_ops
.to_insert_vfork_catchpoint
= NULL
;
2011 es1800_ops
.to_remove_vfork_catchpoint
= NULL
;
2012 es1800_ops
.to_has_forked
= NULL
;
2013 es1800_ops
.to_has_vforked
= NULL
;
2014 es1800_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2015 es1800_ops
.to_post_follow_vfork
= NULL
;
2016 es1800_ops
.to_insert_exec_catchpoint
= NULL
;
2017 es1800_ops
.to_remove_exec_catchpoint
= NULL
;
2018 es1800_ops
.to_has_execd
= NULL
;
2019 es1800_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2020 es1800_ops
.to_has_exited
= NULL
;
2021 es1800_ops
.to_mourn_inferior
= NULL
;
2022 es1800_ops
.to_can_run
= 0;
2023 es1800_ops
.to_notice_signals
= 0;
2024 es1800_ops
.to_thread_alive
= 0;
2025 es1800_ops
.to_stop
= 0;
2026 es1800_ops
.to_pid_to_exec_file
= NULL
;
2027 es1800_ops
.to_core_file_to_sym_file
= NULL
;
2028 es1800_ops
.to_stratum
= core_stratum
;
2029 es1800_ops
.DONT_USE
= 0;
2030 es1800_ops
.to_has_all_memory
= 0;
2031 es1800_ops
.to_has_memory
= 1;
2032 es1800_ops
.to_has_stack
= 0;
2033 es1800_ops
.to_has_registers
= 0;
2034 es1800_ops
.to_has_execution
= 0;
2035 es1800_ops
.to_sections
= NULL
;
2036 es1800_ops
.to_sections_end
= NULL
;
2037 es1800_ops
.to_magic
= OPS_MAGIC
;
2040 /* Define the target subroutine names */
2042 struct target_ops es1800_child_ops
;
2045 init_es1800_child_ops (void)
2047 es1800_child_ops
.to_shortname
= "es1800_process";
2048 es1800_child_ops
.to_longname
= "Remote serial target in ES1800-emulator protocol";
2049 es1800_child_ops
.to_doc
= "Remote debugging on the es1800 emulator via a serial line.\n\
2050 Specify the serial device it is connected to (e.g. /dev/ttya).";
2051 es1800_child_ops
.to_open
= es1800_child_open
;
2052 es1800_child_ops
.to_close
= NULL
;
2053 es1800_child_ops
.to_attach
= es1800_attach
;
2054 es1800_child_ops
.to_post_attach
= NULL
;
2055 es1800_child_ops
.to_require_attach
= NULL
;
2056 es1800_child_ops
.to_detach
= es1800_child_detach
;
2057 es1800_child_ops
.to_require_detach
= NULL
;
2058 es1800_child_ops
.to_resume
= es1800_resume
;
2059 es1800_child_ops
.to_wait
= es1800_wait
;
2060 es1800_child_ops
.to_post_wait
= NULL
;
2061 es1800_child_ops
.to_fetch_registers
= es1800_fetch_register
;
2062 es1800_child_ops
.to_store_registers
= es1800_store_register
;
2063 es1800_child_ops
.to_prepare_to_store
= es1800_prepare_to_store
;
2064 es1800_child_ops
.to_xfer_memory
= es1800_xfer_inferior_memory
;
2065 es1800_child_ops
.to_files_info
= es1800_files_info
;
2066 es1800_child_ops
.to_insert_breakpoint
= es1800_insert_breakpoint
;
2067 es1800_child_ops
.to_remove_breakpoint
= es1800_remove_breakpoint
;
2068 es1800_child_ops
.to_terminal_init
= NULL
;
2069 es1800_child_ops
.to_terminal_inferior
= NULL
;
2070 es1800_child_ops
.to_terminal_ours_for_output
= NULL
;
2071 es1800_child_ops
.to_terminal_ours
= NULL
;
2072 es1800_child_ops
.to_terminal_info
= NULL
;
2073 es1800_child_ops
.to_kill
= es1800_kill
;
2074 es1800_child_ops
.to_load
= es1800_load
;
2075 es1800_child_ops
.to_lookup_symbol
= NULL
;
2076 es1800_child_ops
.to_create_inferior
= es1800_create_inferior
;
2077 es1800_child_ops
.to_post_startup_inferior
= NULL
;
2078 es1800_child_ops
.to_acknowledge_created_inferior
= NULL
;
2079 es1800_child_ops
.to_clone_and_follow_inferior
= NULL
;
2080 es1800_child_ops
.to_post_follow_inferior_by_clone
= NULL
;
2081 es1800_child_ops
.to_insert_fork_catchpoint
= NULL
;
2082 es1800_child_ops
.to_remove_fork_catchpoint
= NULL
;
2083 es1800_child_ops
.to_insert_vfork_catchpoint
= NULL
;
2084 es1800_child_ops
.to_remove_vfork_catchpoint
= NULL
;
2085 es1800_child_ops
.to_has_forked
= NULL
;
2086 es1800_child_ops
.to_has_vforked
= NULL
;
2087 es1800_child_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
2088 es1800_child_ops
.to_post_follow_vfork
= NULL
;
2089 es1800_child_ops
.to_insert_exec_catchpoint
= NULL
;
2090 es1800_child_ops
.to_remove_exec_catchpoint
= NULL
;
2091 es1800_child_ops
.to_has_execd
= NULL
;
2092 es1800_child_ops
.to_reported_exec_events_per_exec_call
= NULL
;
2093 es1800_child_ops
.to_has_exited
= NULL
;
2094 es1800_child_ops
.to_mourn_inferior
= es1800_mourn_inferior
;
2095 es1800_child_ops
.to_can_run
= 0;
2096 es1800_child_ops
.to_notice_signals
= 0;
2097 es1800_child_ops
.to_thread_alive
= 0;
2098 es1800_child_ops
.to_stop
= 0;
2099 es1800_child_ops
.to_pid_to_exec_file
= NULL
;
2100 es1800_child_ops
.to_core_file_to_sym_file
= NULL
;
2101 es1800_child_ops
.to_stratum
= process_stratum
;
2102 es1800_child_ops
.DONT_USE
= 0;
2103 es1800_child_ops
.to_has_all_memory
= 1;
2104 es1800_child_ops
.to_has_memory
= 1;
2105 es1800_child_ops
.to_has_stack
= 1;
2106 es1800_child_ops
.to_has_registers
= 1;
2107 es1800_child_ops
.to_has_execution
= 1;
2108 es1800_child_ops
.to_sections
= NULL
;
2109 es1800_child_ops
.to_sections_end
= NULL
;
2110 es1800_child_ops
.to_magic
= OPS_MAGIC
;
2114 _initialize_es1800 (void)
2117 init_es1800_child_ops ();
2118 add_target (&es1800_ops
);
2119 add_target (&es1800_child_ops
);
2120 #ifdef PROVIDE_TRANSPARENT
2121 add_com ("transparent", class_support
, es1800_transparent
,
2122 "Start transparent communication with the ES 1800 emulator.");
2123 #endif /* PROVIDE_TRANSPARENT */
2124 add_com ("init_break", class_support
, es1800_init_break
,
2125 "Download break routine and initialize break facility on ES 1800");