Commit | Line | Data |
---|---|---|
4d210288 AC |
1 | // OBSOLETE /* Memory-access and commands for remote NINDY process, for GDB. |
2 | // OBSOLETE | |
3 | // OBSOLETE Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, | |
4 | // OBSOLETE 2000, 2001, 2002 Free Software Foundation, Inc. | |
5 | // OBSOLETE | |
6 | // OBSOLETE Contributed by Intel Corporation. Modified from remote.c by Chris Benenati. | |
7 | // OBSOLETE | |
8 | // OBSOLETE GDB is distributed in the hope that it will be useful, but WITHOUT ANY | |
9 | // OBSOLETE WARRANTY. No author or distributor accepts responsibility to anyone | |
10 | // OBSOLETE for the consequences of using it or for whether it serves any | |
11 | // OBSOLETE particular purpose or works at all, unless he says so in writing. | |
12 | // OBSOLETE Refer to the GDB General Public License for full details. | |
13 | // OBSOLETE | |
14 | // OBSOLETE Everyone is granted permission to copy, modify and redistribute GDB, | |
15 | // OBSOLETE but only under the conditions described in the GDB General Public | |
16 | // OBSOLETE License. A copy of this license is supposed to have been given to you | |
17 | // OBSOLETE along with GDB so you can know your rights and responsibilities. It | |
18 | // OBSOLETE should be in a file named COPYING. Among other things, the copyright | |
19 | // OBSOLETE notice and this notice must be preserved on all copies. | |
20 | // OBSOLETE | |
21 | // OBSOLETE In other words, go ahead and share GDB, but don't try to stop | |
22 | // OBSOLETE anyone else from sharing it farther. Help stamp out software hoarding! */ | |
23 | // OBSOLETE | |
24 | // OBSOLETE /* | |
25 | // OBSOLETE Except for the data cache routines, this file bears little resemblence | |
26 | // OBSOLETE to remote.c. A new (although similar) protocol has been specified, and | |
27 | // OBSOLETE portions of the code are entirely dependent on having an i80960 with a | |
28 | // OBSOLETE NINDY ROM monitor at the other end of the line. | |
29 | // OBSOLETE */ | |
30 | // OBSOLETE | |
31 | // OBSOLETE /***************************************************************************** | |
32 | // OBSOLETE * | |
33 | // OBSOLETE * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR. | |
34 | // OBSOLETE * | |
35 | // OBSOLETE * | |
36 | // OBSOLETE * MODES OF OPERATION | |
37 | // OBSOLETE * ----- -- --------- | |
38 | // OBSOLETE * | |
39 | // OBSOLETE * As far as NINDY is concerned, GDB is always in one of two modes: command | |
40 | // OBSOLETE * mode or passthrough mode. | |
41 | // OBSOLETE * | |
42 | // OBSOLETE * In command mode (the default) pre-defined packets containing requests | |
43 | // OBSOLETE * are sent by GDB to NINDY. NINDY never talks except in reponse to a request. | |
44 | // OBSOLETE * | |
45 | // OBSOLETE * Once the the user program is started, GDB enters passthrough mode, to give | |
46 | // OBSOLETE * the user program access to the terminal. GDB remains in this mode until | |
47 | // OBSOLETE * NINDY indicates that the program has stopped. | |
48 | // OBSOLETE * | |
49 | // OBSOLETE * | |
50 | // OBSOLETE * PASSTHROUGH MODE | |
51 | // OBSOLETE * ----------- ---- | |
52 | // OBSOLETE * | |
53 | // OBSOLETE * GDB writes all input received from the keyboard directly to NINDY, and writes | |
54 | // OBSOLETE * all characters received from NINDY directly to the monitor. | |
55 | // OBSOLETE * | |
56 | // OBSOLETE * Keyboard input is neither buffered nor echoed to the monitor. | |
57 | // OBSOLETE * | |
58 | // OBSOLETE * GDB remains in passthrough mode until NINDY sends a single ^P character, | |
59 | // OBSOLETE * to indicate that the user process has stopped. | |
60 | // OBSOLETE * | |
61 | // OBSOLETE * Note: | |
62 | // OBSOLETE * GDB assumes NINDY performs a 'flushreg' when the user program stops. | |
63 | // OBSOLETE * | |
64 | // OBSOLETE * | |
65 | // OBSOLETE * COMMAND MODE | |
66 | // OBSOLETE * ------- ---- | |
67 | // OBSOLETE * | |
68 | // OBSOLETE * All info (except for message ack and nak) is transferred between gdb | |
69 | // OBSOLETE * and the remote processor in messages of the following format: | |
70 | // OBSOLETE * | |
71 | // OBSOLETE * <info>#<checksum> | |
72 | // OBSOLETE * | |
73 | // OBSOLETE * where | |
74 | // OBSOLETE * # is a literal character | |
75 | // OBSOLETE * | |
76 | // OBSOLETE * <info> ASCII information; all numeric information is in the | |
77 | // OBSOLETE * form of hex digits ('0'-'9' and lowercase 'a'-'f'). | |
78 | // OBSOLETE * | |
79 | // OBSOLETE * <checksum> | |
80 | // OBSOLETE * is a pair of ASCII hex digits representing an 8-bit | |
81 | // OBSOLETE * checksum formed by adding together each of the | |
82 | // OBSOLETE * characters in <info>. | |
83 | // OBSOLETE * | |
84 | // OBSOLETE * The receiver of a message always sends a single character to the sender | |
85 | // OBSOLETE * to indicate that the checksum was good ('+') or bad ('-'); the sender | |
86 | // OBSOLETE * re-transmits the entire message over until a '+' is received. | |
87 | // OBSOLETE * | |
88 | // OBSOLETE * In response to a command NINDY always sends back either data or | |
89 | // OBSOLETE * a result code of the form "Xnn", where "nn" are hex digits and "X00" | |
90 | // OBSOLETE * means no errors. (Exceptions: the "s" and "c" commands don't respond.) | |
91 | // OBSOLETE * | |
92 | // OBSOLETE * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A | |
93 | // OBSOLETE * FULL DESCRIPTION OF LEGAL COMMANDS. | |
94 | // OBSOLETE * | |
95 | // OBSOLETE * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST | |
96 | // OBSOLETE * OF STOP CODES. | |
97 | // OBSOLETE * | |
98 | // OBSOLETE ***************************************************************************/ | |
99 | // OBSOLETE | |
100 | // OBSOLETE #include "defs.h" | |
101 | // OBSOLETE #include <signal.h> | |
102 | // OBSOLETE #include <sys/types.h> | |
103 | // OBSOLETE #include <setjmp.h> | |
104 | // OBSOLETE | |
105 | // OBSOLETE #include "frame.h" | |
106 | // OBSOLETE #include "inferior.h" | |
107 | // OBSOLETE #include "bfd.h" | |
108 | // OBSOLETE #include "symfile.h" | |
109 | // OBSOLETE #include "target.h" | |
110 | // OBSOLETE #include "gdbcore.h" | |
111 | // OBSOLETE #include "command.h" | |
112 | // OBSOLETE #include "floatformat.h" | |
113 | // OBSOLETE #include "regcache.h" | |
114 | // OBSOLETE | |
115 | // OBSOLETE #include <sys/file.h> | |
116 | // OBSOLETE #include <ctype.h> | |
117 | // OBSOLETE #include "serial.h" | |
118 | // OBSOLETE #include "nindy-share/env.h" | |
119 | // OBSOLETE #include "nindy-share/stop.h" | |
120 | // OBSOLETE #include "remote-utils.h" | |
121 | // OBSOLETE | |
122 | // OBSOLETE extern int unlink (); | |
123 | // OBSOLETE extern char *getenv (); | |
124 | // OBSOLETE extern char *mktemp (); | |
125 | // OBSOLETE | |
126 | // OBSOLETE extern void generic_mourn_inferior (); | |
127 | // OBSOLETE | |
128 | // OBSOLETE extern struct target_ops nindy_ops; | |
129 | // OBSOLETE extern FILE *instream; | |
130 | // OBSOLETE | |
131 | // OBSOLETE extern char ninStopWhy (); | |
132 | // OBSOLETE extern int ninMemGet (); | |
133 | // OBSOLETE extern int ninMemPut (); | |
134 | // OBSOLETE | |
135 | // OBSOLETE int nindy_initial_brk; /* nonzero if want to send an initial BREAK to nindy */ | |
136 | // OBSOLETE int nindy_old_protocol; /* nonzero if want to use old protocol */ | |
137 | // OBSOLETE char *nindy_ttyname; /* name of tty to talk to nindy on, or null */ | |
138 | // OBSOLETE | |
139 | // OBSOLETE #define DLE '\020' /* Character NINDY sends to indicate user program has | |
140 | // OBSOLETE * halted. */ | |
141 | // OBSOLETE #define TRUE 1 | |
142 | // OBSOLETE #define FALSE 0 | |
143 | // OBSOLETE | |
144 | // OBSOLETE /* From nindy-share/nindy.c. */ | |
145 | // OBSOLETE extern struct serial *nindy_serial; | |
146 | // OBSOLETE | |
147 | // OBSOLETE static int have_regs = 0; /* 1 iff regs read since i960 last halted */ | |
148 | // OBSOLETE static int regs_changed = 0; /* 1 iff regs were modified since last read */ | |
149 | // OBSOLETE | |
150 | // OBSOLETE extern char *exists (); | |
151 | // OBSOLETE | |
152 | // OBSOLETE static void nindy_fetch_registers (int); | |
153 | // OBSOLETE | |
154 | // OBSOLETE static void nindy_store_registers (int); | |
155 | // OBSOLETE \f | |
156 | // OBSOLETE static char *savename; | |
157 | // OBSOLETE | |
158 | // OBSOLETE static void | |
159 | // OBSOLETE nindy_close (int quitting) | |
160 | // OBSOLETE { | |
161 | // OBSOLETE if (nindy_serial != NULL) | |
162 | // OBSOLETE serial_close (nindy_serial); | |
163 | // OBSOLETE nindy_serial = NULL; | |
164 | // OBSOLETE | |
165 | // OBSOLETE if (savename) | |
166 | // OBSOLETE xfree (savename); | |
167 | // OBSOLETE savename = 0; | |
168 | // OBSOLETE } | |
169 | // OBSOLETE | |
170 | // OBSOLETE /* Open a connection to a remote debugger. | |
171 | // OBSOLETE FIXME, there should be "set" commands for the options that are | |
172 | // OBSOLETE now specified with gdb command-line options (old_protocol, | |
173 | // OBSOLETE and initial_brk). */ | |
174 | // OBSOLETE void | |
175 | // OBSOLETE nindy_open (char *name, /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */ | |
176 | // OBSOLETE int from_tty) | |
177 | // OBSOLETE { | |
178 | // OBSOLETE char baudrate[1024]; | |
179 | // OBSOLETE | |
180 | // OBSOLETE if (!name) | |
181 | // OBSOLETE error_no_arg ("serial port device name"); | |
182 | // OBSOLETE | |
183 | // OBSOLETE target_preopen (from_tty); | |
184 | // OBSOLETE | |
185 | // OBSOLETE nindy_close (0); | |
186 | // OBSOLETE | |
187 | // OBSOLETE have_regs = regs_changed = 0; | |
188 | // OBSOLETE | |
189 | // OBSOLETE /* Allow user to interrupt the following -- we could hang if there's | |
190 | // OBSOLETE no NINDY at the other end of the remote tty. */ | |
191 | // OBSOLETE immediate_quit++; | |
192 | // OBSOLETE /* If baud_rate is -1, then ninConnect will not recognize the baud rate | |
193 | // OBSOLETE and will deal with the situation in a (more or less) reasonable | |
194 | // OBSOLETE fashion. */ | |
195 | // OBSOLETE sprintf (baudrate, "%d", baud_rate); | |
196 | // OBSOLETE ninConnect (name, baudrate, | |
197 | // OBSOLETE nindy_initial_brk, !from_tty, nindy_old_protocol); | |
198 | // OBSOLETE immediate_quit--; | |
199 | // OBSOLETE | |
200 | // OBSOLETE if (nindy_serial == NULL) | |
201 | // OBSOLETE { | |
202 | // OBSOLETE perror_with_name (name); | |
203 | // OBSOLETE } | |
204 | // OBSOLETE | |
205 | // OBSOLETE savename = savestring (name, strlen (name)); | |
206 | // OBSOLETE push_target (&nindy_ops); | |
207 | // OBSOLETE | |
208 | // OBSOLETE target_fetch_registers (-1); | |
209 | // OBSOLETE | |
210 | // OBSOLETE init_thread_list (); | |
211 | // OBSOLETE init_wait_for_inferior (); | |
212 | // OBSOLETE clear_proceed_status (); | |
213 | // OBSOLETE normal_stop (); | |
214 | // OBSOLETE } | |
215 | // OBSOLETE | |
216 | // OBSOLETE /* User-initiated quit of nindy operations. */ | |
217 | // OBSOLETE | |
218 | // OBSOLETE static void | |
219 | // OBSOLETE nindy_detach (char *name, int from_tty) | |
220 | // OBSOLETE { | |
221 | // OBSOLETE if (name) | |
222 | // OBSOLETE error ("Too many arguments"); | |
223 | // OBSOLETE pop_target (); | |
224 | // OBSOLETE } | |
225 | // OBSOLETE | |
226 | // OBSOLETE static void | |
227 | // OBSOLETE nindy_files_info (void) | |
228 | // OBSOLETE { | |
229 | // OBSOLETE /* FIXME: this lies about the baud rate if we autobauded. */ | |
230 | // OBSOLETE printf_unfiltered ("\tAttached to %s at %d bits per second%s%s.\n", savename, | |
231 | // OBSOLETE baud_rate, | |
232 | // OBSOLETE nindy_old_protocol ? " in old protocol" : "", | |
233 | // OBSOLETE nindy_initial_brk ? " with initial break" : ""); | |
234 | // OBSOLETE } | |
235 | // OBSOLETE \f | |
236 | // OBSOLETE /* Return the number of characters in the buffer BUF before | |
237 | // OBSOLETE the first DLE character. N is maximum number of characters to | |
238 | // OBSOLETE consider. */ | |
239 | // OBSOLETE | |
240 | // OBSOLETE static | |
241 | // OBSOLETE int | |
242 | // OBSOLETE non_dle (char *buf, int n) | |
243 | // OBSOLETE { | |
244 | // OBSOLETE int i; | |
245 | // OBSOLETE | |
246 | // OBSOLETE for (i = 0; i < n; i++) | |
247 | // OBSOLETE { | |
248 | // OBSOLETE if (buf[i] == DLE) | |
249 | // OBSOLETE { | |
250 | // OBSOLETE break; | |
251 | // OBSOLETE } | |
252 | // OBSOLETE } | |
253 | // OBSOLETE return i; | |
254 | // OBSOLETE } | |
255 | // OBSOLETE \f | |
256 | // OBSOLETE /* Tell the remote machine to resume. */ | |
257 | // OBSOLETE | |
258 | // OBSOLETE void | |
259 | // OBSOLETE nindy_resume (ptid_t ptid, int step, enum target_signal siggnal) | |
260 | // OBSOLETE { | |
261 | // OBSOLETE if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal) | |
262 | // OBSOLETE warning ("Can't send signals to remote NINDY targets."); | |
263 | // OBSOLETE | |
264 | // OBSOLETE if (regs_changed) | |
265 | // OBSOLETE { | |
266 | // OBSOLETE nindy_store_registers (-1); | |
267 | // OBSOLETE regs_changed = 0; | |
268 | // OBSOLETE } | |
269 | // OBSOLETE have_regs = 0; | |
270 | // OBSOLETE ninGo (step); | |
271 | // OBSOLETE } | |
272 | // OBSOLETE \f | |
273 | // OBSOLETE /* FIXME, we can probably use the normal terminal_inferior stuff here. | |
274 | // OBSOLETE We have to do terminal_inferior and then set up the passthrough | |
275 | // OBSOLETE settings initially. Thereafter, terminal_ours and terminal_inferior | |
276 | // OBSOLETE will automatically swap the settings around for us. */ | |
277 | // OBSOLETE | |
278 | // OBSOLETE struct clean_up_tty_args | |
279 | // OBSOLETE { | |
280 | // OBSOLETE serial_ttystate state; | |
281 | // OBSOLETE struct serial *serial; | |
282 | // OBSOLETE }; | |
283 | // OBSOLETE static struct clean_up_tty_args tty_args; | |
284 | // OBSOLETE | |
285 | // OBSOLETE static void | |
286 | // OBSOLETE clean_up_tty (PTR ptrarg) | |
287 | // OBSOLETE { | |
288 | // OBSOLETE struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg; | |
289 | // OBSOLETE serial_set_tty_state (args->serial, args->state); | |
290 | // OBSOLETE xfree (args->state); | |
291 | // OBSOLETE warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n"); | |
292 | // OBSOLETE } | |
293 | // OBSOLETE | |
294 | // OBSOLETE /* Recover from ^Z or ^C while remote process is running */ | |
295 | // OBSOLETE static void (*old_ctrlc) (); | |
296 | // OBSOLETE #ifdef SIGTSTP | |
297 | // OBSOLETE static void (*old_ctrlz) (); | |
298 | // OBSOLETE #endif | |
299 | // OBSOLETE | |
300 | // OBSOLETE static void | |
301 | // OBSOLETE clean_up_int (void) | |
302 | // OBSOLETE { | |
303 | // OBSOLETE serial_set_tty_state (tty_args.serial, tty_args.state); | |
304 | // OBSOLETE xfree (tty_args.state); | |
305 | // OBSOLETE | |
306 | // OBSOLETE signal (SIGINT, old_ctrlc); | |
307 | // OBSOLETE #ifdef SIGTSTP | |
308 | // OBSOLETE signal (SIGTSTP, old_ctrlz); | |
309 | // OBSOLETE #endif | |
310 | // OBSOLETE error ("\n\nYou may need to reset the 80960 and/or reload your program.\n"); | |
311 | // OBSOLETE } | |
312 | // OBSOLETE | |
313 | // OBSOLETE /* Wait until the remote machine stops. While waiting, operate in passthrough | |
314 | // OBSOLETE * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from | |
315 | // OBSOLETE * stdin to NINDY. | |
316 | // OBSOLETE * | |
317 | // OBSOLETE * Return to caller, storing status in 'status' just as `wait' would. | |
318 | // OBSOLETE */ | |
319 | // OBSOLETE | |
320 | // OBSOLETE static ptid_t | |
321 | // OBSOLETE nindy_wait (ptid_t ptid, struct target_waitstatus *status) | |
322 | // OBSOLETE { | |
323 | // OBSOLETE fd_set fds; | |
324 | // OBSOLETE int c; | |
325 | // OBSOLETE char buf[2]; | |
326 | // OBSOLETE int i, n; | |
327 | // OBSOLETE unsigned char stop_exit; | |
328 | // OBSOLETE unsigned char stop_code; | |
329 | // OBSOLETE struct cleanup *old_cleanups; | |
330 | // OBSOLETE long ip_value, fp_value, sp_value; /* Reg values from stop */ | |
331 | // OBSOLETE | |
332 | // OBSOLETE status->kind = TARGET_WAITKIND_EXITED; | |
333 | // OBSOLETE status->value.integer = 0; | |
334 | // OBSOLETE | |
335 | // OBSOLETE /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */ | |
336 | // OBSOLETE | |
337 | // OBSOLETE /* Save current tty attributes, and restore them when done. */ | |
338 | // OBSOLETE tty_args.serial = serial_fdopen (0); | |
339 | // OBSOLETE tty_args.state = serial_get_tty_state (tty_args.serial); | |
340 | // OBSOLETE old_ctrlc = signal (SIGINT, clean_up_int); | |
341 | // OBSOLETE #ifdef SIGTSTP | |
342 | // OBSOLETE old_ctrlz = signal (SIGTSTP, clean_up_int); | |
343 | // OBSOLETE #endif | |
344 | // OBSOLETE | |
345 | // OBSOLETE old_cleanups = make_cleanup (clean_up_tty, &tty_args); | |
346 | // OBSOLETE | |
347 | // OBSOLETE /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret | |
348 | // OBSOLETE <CR> and perform echo. */ | |
349 | // OBSOLETE /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close | |
350 | // OBSOLETE enough. */ | |
351 | // OBSOLETE serial_raw (tty_args.serial); | |
352 | // OBSOLETE | |
353 | // OBSOLETE while (1) | |
354 | // OBSOLETE { | |
355 | // OBSOLETE /* Input on remote */ | |
356 | // OBSOLETE c = serial_readchar (nindy_serial, -1); | |
357 | // OBSOLETE if (c == SERIAL_ERROR) | |
358 | // OBSOLETE { | |
359 | // OBSOLETE error ("Cannot read from serial line"); | |
360 | // OBSOLETE } | |
361 | // OBSOLETE else if (c == 0x1b) /* ESC */ | |
362 | // OBSOLETE { | |
363 | // OBSOLETE c = serial_readchar (nindy_serial, -1); | |
364 | // OBSOLETE c &= ~0x40; | |
365 | // OBSOLETE } | |
366 | // OBSOLETE else if (c != 0x10) /* DLE */ | |
367 | // OBSOLETE /* Write out any characters preceding DLE */ | |
368 | // OBSOLETE { | |
369 | // OBSOLETE buf[0] = (char) c; | |
370 | // OBSOLETE write (1, buf, 1); | |
371 | // OBSOLETE } | |
372 | // OBSOLETE else | |
373 | // OBSOLETE { | |
374 | // OBSOLETE stop_exit = ninStopWhy (&stop_code, | |
375 | // OBSOLETE &ip_value, &fp_value, &sp_value); | |
376 | // OBSOLETE if (!stop_exit && (stop_code == STOP_SRQ)) | |
377 | // OBSOLETE { | |
378 | // OBSOLETE immediate_quit++; | |
379 | // OBSOLETE ninSrq (); | |
380 | // OBSOLETE immediate_quit--; | |
381 | // OBSOLETE } | |
382 | // OBSOLETE else | |
383 | // OBSOLETE { | |
384 | // OBSOLETE /* Get out of loop */ | |
385 | // OBSOLETE supply_register (IP_REGNUM, | |
386 | // OBSOLETE (char *) &ip_value); | |
387 | // OBSOLETE supply_register (FP_REGNUM, | |
388 | // OBSOLETE (char *) &fp_value); | |
389 | // OBSOLETE supply_register (SP_REGNUM, | |
390 | // OBSOLETE (char *) &sp_value); | |
391 | // OBSOLETE break; | |
392 | // OBSOLETE } | |
393 | // OBSOLETE } | |
394 | // OBSOLETE } | |
395 | // OBSOLETE | |
396 | // OBSOLETE serial_set_tty_state (tty_args.serial, tty_args.state); | |
397 | // OBSOLETE xfree (tty_args.state); | |
398 | // OBSOLETE discard_cleanups (old_cleanups); | |
399 | // OBSOLETE | |
400 | // OBSOLETE if (stop_exit) | |
401 | // OBSOLETE { | |
402 | // OBSOLETE status->kind = TARGET_WAITKIND_EXITED; | |
403 | // OBSOLETE status->value.integer = stop_code; | |
404 | // OBSOLETE } | |
405 | // OBSOLETE else | |
406 | // OBSOLETE { | |
407 | // OBSOLETE /* nindy has some special stop code need to be handled */ | |
408 | // OBSOLETE if (stop_code == STOP_GDB_BPT) | |
409 | // OBSOLETE stop_code = TRACE_STEP; | |
410 | // OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; | |
411 | // OBSOLETE status->value.sig = i960_fault_to_signal (stop_code); | |
412 | // OBSOLETE } | |
413 | // OBSOLETE return inferior_ptid; | |
414 | // OBSOLETE } | |
415 | // OBSOLETE | |
416 | // OBSOLETE /* Read the remote registers into the block REGS. */ | |
417 | // OBSOLETE | |
418 | // OBSOLETE /* This is the block that ninRegsGet and ninRegsPut handles. */ | |
419 | // OBSOLETE struct nindy_regs | |
420 | // OBSOLETE { | |
421 | // OBSOLETE char local_regs[16 * 4]; | |
422 | // OBSOLETE char global_regs[16 * 4]; | |
423 | // OBSOLETE char pcw_acw[2 * 4]; | |
424 | // OBSOLETE char ip[4]; | |
425 | // OBSOLETE char tcw[4]; | |
426 | // OBSOLETE char fp_as_double[4 * 8]; | |
427 | // OBSOLETE }; | |
428 | // OBSOLETE | |
429 | // OBSOLETE static void | |
430 | // OBSOLETE nindy_fetch_registers (int regno) | |
431 | // OBSOLETE { | |
432 | // OBSOLETE struct nindy_regs nindy_regs; | |
433 | // OBSOLETE int regnum; | |
434 | // OBSOLETE | |
435 | // OBSOLETE immediate_quit++; | |
436 | // OBSOLETE ninRegsGet ((char *) &nindy_regs); | |
437 | // OBSOLETE immediate_quit--; | |
438 | // OBSOLETE | |
439 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16 * 4); | |
440 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16 * 4); | |
441 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2 * 4); | |
442 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1 * 4); | |
443 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1 * 4); | |
444 | // OBSOLETE memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8); | |
445 | // OBSOLETE | |
446 | // OBSOLETE registers_fetched (); | |
447 | // OBSOLETE } | |
448 | // OBSOLETE | |
449 | // OBSOLETE static void | |
450 | // OBSOLETE nindy_prepare_to_store (void) | |
451 | // OBSOLETE { | |
452 | // OBSOLETE /* Fetch all regs if they aren't already here. */ | |
453 | // OBSOLETE read_register_bytes (0, NULL, REGISTER_BYTES); | |
454 | // OBSOLETE } | |
455 | // OBSOLETE | |
456 | // OBSOLETE static void | |
457 | // OBSOLETE nindy_store_registers (int regno) | |
458 | // OBSOLETE { | |
459 | // OBSOLETE struct nindy_regs nindy_regs; | |
460 | // OBSOLETE int regnum; | |
461 | // OBSOLETE | |
462 | // OBSOLETE memcpy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * 4); | |
463 | // OBSOLETE memcpy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * 4); | |
464 | // OBSOLETE memcpy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2 * 4); | |
465 | // OBSOLETE memcpy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1 * 4); | |
466 | // OBSOLETE memcpy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1 * 4); | |
467 | // OBSOLETE memcpy (nindy_regs.fp_as_double, ®isters[REGISTER_BYTE (FP0_REGNUM)], 8 * 4); | |
468 | // OBSOLETE | |
469 | // OBSOLETE immediate_quit++; | |
470 | // OBSOLETE ninRegsPut ((char *) &nindy_regs); | |
471 | // OBSOLETE immediate_quit--; | |
472 | // OBSOLETE } | |
473 | // OBSOLETE | |
474 | // OBSOLETE /* Copy LEN bytes to or from inferior's memory starting at MEMADDR | |
475 | // OBSOLETE to debugger memory starting at MYADDR. Copy to inferior if | |
476 | // OBSOLETE SHOULD_WRITE is nonzero. Returns the length copied. TARGET is | |
477 | // OBSOLETE unused. */ | |
478 | // OBSOLETE | |
479 | // OBSOLETE int | |
480 | // OBSOLETE nindy_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, | |
481 | // OBSOLETE int should_write, struct mem_attrib *attrib, | |
482 | // OBSOLETE struct target_ops *target) | |
483 | // OBSOLETE { | |
484 | // OBSOLETE int res; | |
485 | // OBSOLETE | |
486 | // OBSOLETE if (len <= 0) | |
487 | // OBSOLETE return 0; | |
488 | // OBSOLETE | |
489 | // OBSOLETE if (should_write) | |
490 | // OBSOLETE res = ninMemPut (memaddr, myaddr, len); | |
491 | // OBSOLETE else | |
492 | // OBSOLETE res = ninMemGet (memaddr, myaddr, len); | |
493 | // OBSOLETE | |
494 | // OBSOLETE return res; | |
495 | // OBSOLETE } | |
496 | // OBSOLETE \f | |
497 | // OBSOLETE static void | |
498 | // OBSOLETE nindy_create_inferior (char *execfile, char *args, char **env) | |
499 | // OBSOLETE { | |
500 | // OBSOLETE int entry_pt; | |
501 | // OBSOLETE int pid; | |
502 | // OBSOLETE | |
503 | // OBSOLETE if (args && *args) | |
504 | // OBSOLETE error ("Can't pass arguments to remote NINDY process"); | |
505 | // OBSOLETE | |
506 | // OBSOLETE if (execfile == 0 || exec_bfd == 0) | |
507 | // OBSOLETE error ("No executable file specified"); | |
508 | // OBSOLETE | |
509 | // OBSOLETE entry_pt = (int) bfd_get_start_address (exec_bfd); | |
510 | // OBSOLETE | |
511 | // OBSOLETE pid = 42; | |
512 | // OBSOLETE | |
513 | // OBSOLETE /* The "process" (board) is already stopped awaiting our commands, and | |
514 | // OBSOLETE the program is already downloaded. We just set its PC and go. */ | |
515 | // OBSOLETE | |
516 | // OBSOLETE inferior_ptid = pid_to_ptid (pid); /* Needed for wait_for_inferior below */ | |
517 | // OBSOLETE | |
518 | // OBSOLETE clear_proceed_status (); | |
519 | // OBSOLETE | |
520 | // OBSOLETE /* Tell wait_for_inferior that we've started a new process. */ | |
521 | // OBSOLETE init_wait_for_inferior (); | |
522 | // OBSOLETE | |
523 | // OBSOLETE /* Set up the "saved terminal modes" of the inferior | |
524 | // OBSOLETE based on what modes we are starting it with. */ | |
525 | // OBSOLETE target_terminal_init (); | |
526 | // OBSOLETE | |
527 | // OBSOLETE /* Install inferior's terminal modes. */ | |
528 | // OBSOLETE target_terminal_inferior (); | |
529 | // OBSOLETE | |
530 | // OBSOLETE /* insert_step_breakpoint (); FIXME, do we need this? */ | |
531 | // OBSOLETE /* Let 'er rip... */ | |
532 | // OBSOLETE proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0); | |
533 | // OBSOLETE } | |
534 | // OBSOLETE | |
535 | // OBSOLETE static void | |
536 | // OBSOLETE reset_command (char *args, int from_tty) | |
537 | // OBSOLETE { | |
538 | // OBSOLETE if (nindy_serial == NULL) | |
539 | // OBSOLETE { | |
540 | // OBSOLETE error ("No target system to reset -- use 'target nindy' command."); | |
541 | // OBSOLETE } | |
542 | // OBSOLETE if (query ("Really reset the target system?", 0, 0)) | |
543 | // OBSOLETE { | |
544 | // OBSOLETE serial_send_break (nindy_serial); | |
545 | // OBSOLETE tty_flush (nindy_serial); | |
546 | // OBSOLETE } | |
547 | // OBSOLETE } | |
548 | // OBSOLETE | |
549 | // OBSOLETE void | |
550 | // OBSOLETE nindy_kill (char *args, int from_tty) | |
551 | // OBSOLETE { | |
552 | // OBSOLETE return; /* Ignore attempts to kill target system */ | |
553 | // OBSOLETE } | |
554 | // OBSOLETE | |
555 | // OBSOLETE /* Clean up when a program exits. | |
556 | // OBSOLETE | |
557 | // OBSOLETE The program actually lives on in the remote processor's RAM, and may be | |
558 | // OBSOLETE run again without a download. Don't leave it full of breakpoint | |
559 | // OBSOLETE instructions. */ | |
560 | // OBSOLETE | |
561 | // OBSOLETE void | |
562 | // OBSOLETE nindy_mourn_inferior (void) | |
563 | // OBSOLETE { | |
564 | // OBSOLETE remove_breakpoints (); | |
565 | // OBSOLETE unpush_target (&nindy_ops); | |
566 | // OBSOLETE generic_mourn_inferior (); /* Do all the proper things now */ | |
567 | // OBSOLETE } | |
568 | // OBSOLETE \f | |
569 | // OBSOLETE /* Pass the args the way catch_errors wants them. */ | |
570 | // OBSOLETE static int | |
571 | // OBSOLETE nindy_open_stub (char *arg) | |
572 | // OBSOLETE { | |
573 | // OBSOLETE nindy_open (arg, 1); | |
574 | // OBSOLETE return 1; | |
575 | // OBSOLETE } | |
576 | // OBSOLETE | |
577 | // OBSOLETE static void | |
578 | // OBSOLETE nindy_load (char *filename, int from_tty) | |
579 | // OBSOLETE { | |
580 | // OBSOLETE asection *s; | |
581 | // OBSOLETE /* Can't do unix style forking on a VMS system, so we'll use bfd to do | |
582 | // OBSOLETE all the work for us | |
583 | // OBSOLETE */ | |
584 | // OBSOLETE | |
585 | // OBSOLETE bfd *file = bfd_openr (filename, 0); | |
586 | // OBSOLETE if (!file) | |
587 | // OBSOLETE { | |
588 | // OBSOLETE perror_with_name (filename); | |
589 | // OBSOLETE return; | |
590 | // OBSOLETE } | |
591 | // OBSOLETE | |
592 | // OBSOLETE if (!bfd_check_format (file, bfd_object)) | |
593 | // OBSOLETE { | |
594 | // OBSOLETE error ("can't prove it's an object file\n"); | |
595 | // OBSOLETE return; | |
596 | // OBSOLETE } | |
597 | // OBSOLETE | |
598 | // OBSOLETE for (s = file->sections; s; s = s->next) | |
599 | // OBSOLETE { | |
600 | // OBSOLETE if (s->flags & SEC_LOAD) | |
601 | // OBSOLETE { | |
602 | // OBSOLETE char *buffer = xmalloc (s->_raw_size); | |
603 | // OBSOLETE bfd_get_section_contents (file, s, buffer, 0, s->_raw_size); | |
604 | // OBSOLETE printf ("Loading section %s, size %x vma %x\n", | |
605 | // OBSOLETE s->name, | |
606 | // OBSOLETE s->_raw_size, | |
607 | // OBSOLETE s->vma); | |
608 | // OBSOLETE ninMemPut (s->vma, buffer, s->_raw_size); | |
609 | // OBSOLETE xfree (buffer); | |
610 | // OBSOLETE } | |
611 | // OBSOLETE } | |
612 | // OBSOLETE bfd_close (file); | |
613 | // OBSOLETE } | |
614 | // OBSOLETE | |
615 | // OBSOLETE static int | |
616 | // OBSOLETE load_stub (char *arg) | |
617 | // OBSOLETE { | |
618 | // OBSOLETE target_load (arg, 1); | |
619 | // OBSOLETE return 1; | |
620 | // OBSOLETE } | |
621 | // OBSOLETE | |
622 | // OBSOLETE /* This routine is run as a hook, just before the main command loop is | |
623 | // OBSOLETE entered. If gdb is configured for the i960, but has not had its | |
624 | // OBSOLETE nindy target specified yet, this will loop prompting the user to do so. | |
625 | // OBSOLETE | |
626 | // OBSOLETE Unlike the loop provided by Intel, we actually let the user get out | |
627 | // OBSOLETE of this with a RETURN. This is useful when e.g. simply examining | |
628 | // OBSOLETE an i960 object file on the host system. */ | |
629 | // OBSOLETE | |
630 | // OBSOLETE void | |
631 | // OBSOLETE nindy_before_main_loop (void) | |
632 | // OBSOLETE { | |
633 | // OBSOLETE char ttyname[100]; | |
634 | // OBSOLETE char *p, *p2; | |
635 | // OBSOLETE | |
636 | // OBSOLETE while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */ | |
637 | // OBSOLETE { /* remote tty not specified yet */ | |
638 | // OBSOLETE if (instream == stdin) | |
639 | // OBSOLETE { | |
640 | // OBSOLETE printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: "); | |
641 | // OBSOLETE gdb_flush (gdb_stdout); | |
642 | // OBSOLETE } | |
643 | // OBSOLETE fgets (ttyname, sizeof (ttyname) - 1, stdin); | |
644 | // OBSOLETE | |
645 | // OBSOLETE /* Strip leading and trailing whitespace */ | |
646 | // OBSOLETE for (p = ttyname; isspace (*p); p++) | |
647 | // OBSOLETE { | |
648 | // OBSOLETE ; | |
649 | // OBSOLETE } | |
650 | // OBSOLETE if (*p == '\0') | |
651 | // OBSOLETE { | |
652 | // OBSOLETE return; /* User just hit spaces or return, wants out */ | |
653 | // OBSOLETE } | |
654 | // OBSOLETE for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++) | |
655 | // OBSOLETE { | |
656 | // OBSOLETE ; | |
657 | // OBSOLETE } | |
658 | // OBSOLETE *p2 = '\0'; | |
659 | // OBSOLETE if (STREQ ("quit", p)) | |
660 | // OBSOLETE { | |
661 | // OBSOLETE exit (1); | |
662 | // OBSOLETE } | |
663 | // OBSOLETE | |
664 | // OBSOLETE if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL)) | |
665 | // OBSOLETE { | |
666 | // OBSOLETE /* Now that we have a tty open for talking to the remote machine, | |
667 | // OBSOLETE download the executable file if one was specified. */ | |
668 | // OBSOLETE if (exec_bfd) | |
669 | // OBSOLETE { | |
670 | // OBSOLETE catch_errors (load_stub, bfd_get_filename (exec_bfd), "", | |
671 | // OBSOLETE RETURN_MASK_ALL); | |
672 | // OBSOLETE } | |
673 | // OBSOLETE } | |
674 | // OBSOLETE } | |
675 | // OBSOLETE } | |
676 | // OBSOLETE \f | |
677 | // OBSOLETE /* Define the target subroutine names */ | |
678 | // OBSOLETE | |
679 | // OBSOLETE struct target_ops nindy_ops; | |
680 | // OBSOLETE | |
681 | // OBSOLETE static void | |
682 | // OBSOLETE init_nindy_ops (void) | |
683 | // OBSOLETE { | |
684 | // OBSOLETE nindy_ops.to_shortname = "nindy"; | |
685 | // OBSOLETE "Remote serial target in i960 NINDY-specific protocol", | |
686 | // OBSOLETE nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\ | |
687 | // OBSOLETE Specify the name of the device the serial line is connected to.\n\ | |
688 | // OBSOLETE The speed (baud rate), whether to use the old NINDY protocol,\n\ | |
689 | // OBSOLETE and whether to send a break on startup, are controlled by options\n\ | |
690 | // OBSOLETE specified when you started GDB."; | |
691 | // OBSOLETE nindy_ops.to_doc = ""; | |
692 | // OBSOLETE nindy_ops.to_open = nindy_open; | |
693 | // OBSOLETE nindy_ops.to_close = nindy_close; | |
694 | // OBSOLETE nindy_ops.to_attach = 0; | |
695 | // OBSOLETE nindy_ops.to_post_attach = NULL; | |
696 | // OBSOLETE nindy_ops.to_require_attach = NULL; | |
697 | // OBSOLETE nindy_ops.to_detach = nindy_detach; | |
698 | // OBSOLETE nindy_ops.to_require_detach = NULL; | |
699 | // OBSOLETE nindy_ops.to_resume = nindy_resume; | |
700 | // OBSOLETE nindy_ops.to_wait = nindy_wait; | |
701 | // OBSOLETE nindy_ops.to_post_wait = NULL; | |
702 | // OBSOLETE nindy_ops.to_fetch_registers = nindy_fetch_registers; | |
703 | // OBSOLETE nindy_ops.to_store_registers = nindy_store_registers; | |
704 | // OBSOLETE nindy_ops.to_prepare_to_store = nindy_prepare_to_store; | |
705 | // OBSOLETE nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory; | |
706 | // OBSOLETE nindy_ops.to_files_info = nindy_files_info; | |
707 | // OBSOLETE nindy_ops.to_insert_breakpoint = memory_insert_breakpoint; | |
708 | // OBSOLETE nindy_ops.to_remove_breakpoint = memory_remove_breakpoint; | |
709 | // OBSOLETE nindy_ops.to_terminal_init = 0; | |
710 | // OBSOLETE nindy_ops.to_terminal_inferior = 0; | |
711 | // OBSOLETE nindy_ops.to_terminal_ours_for_output = 0; | |
712 | // OBSOLETE nindy_ops.to_terminal_ours = 0; | |
713 | // OBSOLETE nindy_ops.to_terminal_info = 0; /* Terminal crud */ | |
714 | // OBSOLETE nindy_ops.to_kill = nindy_kill; | |
715 | // OBSOLETE nindy_ops.to_load = nindy_load; | |
716 | // OBSOLETE nindy_ops.to_lookup_symbol = 0; /* lookup_symbol */ | |
717 | // OBSOLETE nindy_ops.to_create_inferior = nindy_create_inferior; | |
718 | // OBSOLETE nindy_ops.to_post_startup_inferior = NULL; | |
719 | // OBSOLETE nindy_ops.to_acknowledge_created_inferior = NULL; | |
720 | // OBSOLETE nindy_ops.to_clone_and_follow_inferior = NULL; | |
721 | // OBSOLETE nindy_ops.to_post_follow_inferior_by_clone = NULL; | |
722 | // OBSOLETE nindy_ops.to_insert_fork_catchpoint = NULL; | |
723 | // OBSOLETE nindy_ops.to_remove_fork_catchpoint = NULL; | |
724 | // OBSOLETE nindy_ops.to_insert_vfork_catchpoint = NULL; | |
725 | // OBSOLETE nindy_ops.to_remove_vfork_catchpoint = NULL; | |
726 | // OBSOLETE nindy_ops.to_has_forked = NULL; | |
727 | // OBSOLETE nindy_ops.to_has_vforked = NULL; | |
728 | // OBSOLETE nindy_ops.to_can_follow_vfork_prior_to_exec = NULL; | |
729 | // OBSOLETE nindy_ops.to_post_follow_vfork = NULL; | |
730 | // OBSOLETE nindy_ops.to_insert_exec_catchpoint = NULL; | |
731 | // OBSOLETE nindy_ops.to_remove_exec_catchpoint = NULL; | |
732 | // OBSOLETE nindy_ops.to_has_execd = NULL; | |
733 | // OBSOLETE nindy_ops.to_reported_exec_events_per_exec_call = NULL; | |
734 | // OBSOLETE nindy_ops.to_has_exited = NULL; | |
735 | // OBSOLETE nindy_ops.to_mourn_inferior = nindy_mourn_inferior; | |
736 | // OBSOLETE nindy_ops.to_can_run = 0; /* can_run */ | |
737 | // OBSOLETE nindy_ops.to_notice_signals = 0; /* notice_signals */ | |
738 | // OBSOLETE nindy_ops.to_thread_alive = 0; /* to_thread_alive */ | |
739 | // OBSOLETE nindy_ops.to_stop = 0; /* to_stop */ | |
740 | // OBSOLETE nindy_ops.to_pid_to_exec_file = NULL; | |
741 | // OBSOLETE nindy_ops.to_stratum = process_stratum; | |
742 | // OBSOLETE nindy_ops.DONT_USE = 0; /* next */ | |
743 | // OBSOLETE nindy_ops.to_has_all_memory = 1; | |
744 | // OBSOLETE nindy_ops.to_has_memory = 1; | |
745 | // OBSOLETE nindy_ops.to_has_stack = 1; | |
746 | // OBSOLETE nindy_ops.to_has_registers = 1; | |
747 | // OBSOLETE nindy_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */ | |
748 | // OBSOLETE nindy_ops.to_sections = 0; | |
749 | // OBSOLETE nindy_ops.to_sections_end = 0; /* Section pointers */ | |
750 | // OBSOLETE nindy_ops.to_magic = OPS_MAGIC; /* Always the last thing */ | |
751 | // OBSOLETE } | |
752 | // OBSOLETE | |
753 | // OBSOLETE void | |
754 | // OBSOLETE _initialize_nindy (void) | |
755 | // OBSOLETE { | |
756 | // OBSOLETE init_nindy_ops (); | |
757 | // OBSOLETE add_target (&nindy_ops); | |
758 | // OBSOLETE add_com ("reset", class_obscure, reset_command, | |
759 | // OBSOLETE "Send a 'break' to the remote target system.\n\ | |
760 | // OBSOLETE Only useful if the target has been equipped with a circuit\n\ | |
761 | // OBSOLETE to perform a hard reset when a break is detected."); | |
762 | // OBSOLETE } |