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