* MAINTAINERS: Add myself as dcache.c maintainer.
[deliverable/binutils-gdb.git] / gdb / remote-nindy.c
CommitLineData
c906108c
SS
1/* Memory-access and commands for remote NINDY process, for GDB.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Contributed by Intel Corporation. Modified from remote.c by Chris Benenati.
4
c5aa993b
JM
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 */
c906108c
SS
21
22/*
c5aa993b
JM
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 */
c906108c
SS
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 *
96 ***************************************************************************/
97
98#include "defs.h"
99#include <signal.h>
100#include <sys/types.h>
101#include <setjmp.h>
102
103#include "frame.h"
104#include "inferior.h"
105#include "bfd.h"
106#include "symfile.h"
107#include "target.h"
108#include "gdbcore.h"
109#include "command.h"
110#include "floatformat.h"
111
03f2053f 112#include "gdb_wait.h"
c906108c
SS
113#include <sys/file.h>
114#include <ctype.h>
115#include "serial.h"
116#include "nindy-share/env.h"
117#include "nindy-share/stop.h"
118
119#include "dcache.h"
120#include "remote-utils.h"
121
122static DCACHE *nindy_dcache;
123
c5aa993b
JM
124extern int unlink ();
125extern char *getenv ();
126extern char *mktemp ();
c906108c
SS
127
128extern void generic_mourn_inferior ();
129
130extern struct target_ops nindy_ops;
131extern FILE *instream;
132
133extern char ninStopWhy ();
134extern int ninMemGet ();
135extern int ninMemPut ();
136
c5aa993b
JM
137int nindy_initial_brk; /* nonzero if want to send an initial BREAK to nindy */
138int nindy_old_protocol; /* nonzero if want to use old protocol */
139char *nindy_ttyname; /* name of tty to talk to nindy on, or null */
c906108c 140
c5aa993b
JM
141#define DLE '\020' /* Character NINDY sends to indicate user program has
142 * halted. */
c906108c
SS
143#define TRUE 1
144#define FALSE 0
145
146/* From nindy-share/nindy.c. */
147extern serial_t nindy_serial;
148
149static int have_regs = 0; /* 1 iff regs read since i960 last halted */
150static int regs_changed = 0; /* 1 iff regs were modified since last read */
151
c5aa993b 152extern char *exists ();
c906108c 153
a14ed312 154static void nindy_fetch_registers (int);
c906108c 155
a14ed312 156static void nindy_store_registers (int);
c906108c
SS
157\f
158static char *savename;
159
160static void
fba45db2 161nindy_close (int quitting)
c906108c
SS
162{
163 if (nindy_serial != NULL)
164 SERIAL_CLOSE (nindy_serial);
165 nindy_serial = NULL;
166
167 if (savename)
168 free (savename);
169 savename = 0;
170}
171
172/* Open a connection to a remote debugger.
173 FIXME, there should be "set" commands for the options that are
174 now specified with gdb command-line options (old_protocol,
175 and initial_brk). */
176void
fba45db2
KB
177nindy_open (char *name, /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
178 int from_tty)
c906108c
SS
179{
180 char baudrate[1024];
181
182 if (!name)
183 error_no_arg ("serial port device name");
184
185 target_preopen (from_tty);
186
187 nindy_close (0);
188
189 have_regs = regs_changed = 0;
f1d7622b
C
190
191 if (!nindy_dcache)
192 nindy_dcache = dcache_init (ninMemGet, ninMemPut);
193 else
e99586d5 194 dcache_invd (nindy_dcache);
c906108c
SS
195
196 /* Allow user to interrupt the following -- we could hang if there's
197 no NINDY at the other end of the remote tty. */
198 immediate_quit++;
199 /* If baud_rate is -1, then ninConnect will not recognize the baud rate
200 and will deal with the situation in a (more or less) reasonable
201 fashion. */
c5aa993b
JM
202 sprintf (baudrate, "%d", baud_rate);
203 ninConnect (name, baudrate,
204 nindy_initial_brk, !from_tty, nindy_old_protocol);
c906108c
SS
205 immediate_quit--;
206
207 if (nindy_serial == NULL)
208 {
209 perror_with_name (name);
210 }
211
212 savename = savestring (name, strlen (name));
213 push_target (&nindy_ops);
214
c5aa993b 215 target_fetch_registers (-1);
c906108c
SS
216
217 init_thread_list ();
218 init_wait_for_inferior ();
219 clear_proceed_status ();
220 normal_stop ();
221}
222
223/* User-initiated quit of nindy operations. */
224
225static void
fba45db2 226nindy_detach (char *name, int from_tty)
c906108c
SS
227{
228 if (name)
229 error ("Too many arguments");
230 pop_target ();
231}
232
233static void
fba45db2 234nindy_files_info (void)
c906108c
SS
235{
236 /* FIXME: this lies about the baud rate if we autobauded. */
c5aa993b
JM
237 printf_unfiltered ("\tAttached to %s at %d bits per second%s%s.\n", savename,
238 baud_rate,
239 nindy_old_protocol ? " in old protocol" : "",
240 nindy_initial_brk ? " with initial break" : "");
c906108c
SS
241}
242\f
243/* Return the number of characters in the buffer before
244 the first DLE character. */
245
246static
247int
c5aa993b
JM
248non_dle (buf, n)
249 char *buf; /* Character buffer; NOT '\0'-terminated */
250 int n; /* Number of characters in buffer */
c906108c
SS
251{
252 int i;
253
c5aa993b
JM
254 for (i = 0; i < n; i++)
255 {
256 if (buf[i] == DLE)
257 {
258 break;
259 }
c906108c 260 }
c906108c
SS
261 return i;
262}
263\f
264/* Tell the remote machine to resume. */
265
266void
fba45db2 267nindy_resume (int pid, int step, enum target_signal siggnal)
c906108c
SS
268{
269 if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
270 warning ("Can't send signals to remote NINDY targets.");
271
e99586d5 272 dcache_invd (nindy_dcache);
c5aa993b 273 if (regs_changed)
c906108c
SS
274 {
275 nindy_store_registers (-1);
276 regs_changed = 0;
277 }
278 have_regs = 0;
c5aa993b 279 ninGo (step);
c906108c
SS
280}
281\f
282/* FIXME, we can probably use the normal terminal_inferior stuff here.
283 We have to do terminal_inferior and then set up the passthrough
284 settings initially. Thereafter, terminal_ours and terminal_inferior
285 will automatically swap the settings around for us. */
286
c5aa993b
JM
287struct clean_up_tty_args
288{
c906108c
SS
289 serial_ttystate state;
290 serial_t serial;
291};
c5aa993b 292static struct clean_up_tty_args tty_args;
c906108c
SS
293
294static void
fba45db2 295clean_up_tty (PTR ptrarg)
c906108c
SS
296{
297 struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
298 SERIAL_SET_TTY_STATE (args->serial, args->state);
299 free (args->state);
300 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
301}
302
303/* Recover from ^Z or ^C while remote process is running */
c5aa993b 304static void (*old_ctrlc) ();
c906108c 305#ifdef SIGTSTP
c5aa993b 306static void (*old_ctrlz) ();
c906108c
SS
307#endif
308
309static void
fba45db2 310clean_up_int (void)
c906108c
SS
311{
312 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
313 free (tty_args.state);
314
c5aa993b 315 signal (SIGINT, old_ctrlc);
c906108c 316#ifdef SIGTSTP
c5aa993b 317 signal (SIGTSTP, old_ctrlz);
c906108c 318#endif
c5aa993b 319 error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
c906108c
SS
320}
321
322/* Wait until the remote machine stops. While waiting, operate in passthrough
323 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
324 * stdin to NINDY.
325 *
326 * Return to caller, storing status in 'status' just as `wait' would.
327 */
328
329static int
fba45db2 330nindy_wait (int pid, struct target_waitstatus *status)
c906108c
SS
331{
332 fd_set fds;
333 int c;
334 char buf[2];
335 int i, n;
336 unsigned char stop_exit;
337 unsigned char stop_code;
338 struct cleanup *old_cleanups;
339 long ip_value, fp_value, sp_value; /* Reg values from stop */
340
341 status->kind = TARGET_WAITKIND_EXITED;
342 status->value.integer = 0;
343
344 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
345
346 /* Save current tty attributes, and restore them when done. */
347 tty_args.serial = SERIAL_FDOPEN (0);
348 tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
c5aa993b 349 old_ctrlc = signal (SIGINT, clean_up_int);
c906108c 350#ifdef SIGTSTP
c5aa993b 351 old_ctrlz = signal (SIGTSTP, clean_up_int);
c906108c
SS
352#endif
353
354 old_cleanups = make_cleanup (clean_up_tty, &tty_args);
355
356 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
357 <CR> and perform echo. */
358 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
359 enough. */
360 SERIAL_RAW (tty_args.serial);
361
362 while (1)
363 {
364 /* Input on remote */
365 c = SERIAL_READCHAR (nindy_serial, -1);
366 if (c == SERIAL_ERROR)
367 {
368 error ("Cannot read from serial line");
369 }
c5aa993b 370 else if (c == 0x1b) /* ESC */
c906108c
SS
371 {
372 c = SERIAL_READCHAR (nindy_serial, -1);
373 c &= ~0x40;
c5aa993b
JM
374 }
375 else if (c != 0x10) /* DLE */
c906108c
SS
376 /* Write out any characters preceding DLE */
377 {
c5aa993b 378 buf[0] = (char) c;
c906108c
SS
379 write (1, buf, 1);
380 }
381 else
382 {
c5aa993b
JM
383 stop_exit = ninStopWhy (&stop_code,
384 &ip_value, &fp_value, &sp_value);
c906108c
SS
385 if (!stop_exit && (stop_code == STOP_SRQ))
386 {
387 immediate_quit++;
c5aa993b 388 ninSrq ();
c906108c
SS
389 immediate_quit--;
390 }
391 else
392 {
393 /* Get out of loop */
c5aa993b
JM
394 supply_register (IP_REGNUM,
395 (char *) &ip_value);
396 supply_register (FP_REGNUM,
397 (char *) &fp_value);
398 supply_register (SP_REGNUM,
399 (char *) &sp_value);
c906108c
SS
400 break;
401 }
402 }
403 }
404
405 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
406 free (tty_args.state);
407 discard_cleanups (old_cleanups);
408
409 if (stop_exit)
410 {
411 status->kind = TARGET_WAITKIND_EXITED;
412 status->value.integer = stop_code;
413 }
414 else
415 {
416 /* nindy has some special stop code need to be handled */
417 if (stop_code == STOP_GDB_BPT)
418 stop_code = TRACE_STEP;
419 status->kind = TARGET_WAITKIND_STOPPED;
420 status->value.sig = i960_fault_to_signal (stop_code);
421 }
422 return inferior_pid;
423}
424
425/* Read the remote registers into the block REGS. */
426
427/* This is the block that ninRegsGet and ninRegsPut handles. */
c5aa993b
JM
428struct nindy_regs
429{
430 char local_regs[16 * 4];
431 char global_regs[16 * 4];
432 char pcw_acw[2 * 4];
433 char ip[4];
434 char tcw[4];
435 char fp_as_double[4 * 8];
c906108c
SS
436};
437
438static void
fba45db2 439nindy_fetch_registers (int regno)
c906108c
SS
440{
441 struct nindy_regs nindy_regs;
442 int regnum;
443
444 immediate_quit++;
c5aa993b 445 ninRegsGet ((char *) &nindy_regs);
c906108c
SS
446 immediate_quit--;
447
c5aa993b
JM
448 memcpy (&registers[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16 * 4);
449 memcpy (&registers[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16 * 4);
450 memcpy (&registers[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2 * 4);
451 memcpy (&registers[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1 * 4);
452 memcpy (&registers[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1 * 4);
c906108c
SS
453 memcpy (&registers[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
454
455 registers_fetched ();
456}
457
458static void
fba45db2 459nindy_prepare_to_store (void)
c906108c
SS
460{
461 /* Fetch all regs if they aren't already here. */
462 read_register_bytes (0, NULL, REGISTER_BYTES);
463}
464
465static void
fba45db2 466nindy_store_registers (int regno)
c906108c
SS
467{
468 struct nindy_regs nindy_regs;
469 int regnum;
470
c5aa993b
JM
471 memcpy (nindy_regs.local_regs, &registers[REGISTER_BYTE (R0_REGNUM)], 16 * 4);
472 memcpy (nindy_regs.global_regs, &registers[REGISTER_BYTE (G0_REGNUM)], 16 * 4);
473 memcpy (nindy_regs.pcw_acw, &registers[REGISTER_BYTE (PCW_REGNUM)], 2 * 4);
474 memcpy (nindy_regs.ip, &registers[REGISTER_BYTE (IP_REGNUM)], 1 * 4);
475 memcpy (nindy_regs.tcw, &registers[REGISTER_BYTE (TCW_REGNUM)], 1 * 4);
476 memcpy (nindy_regs.fp_as_double, &registers[REGISTER_BYTE (FP0_REGNUM)], 8 * 4);
c906108c
SS
477
478 immediate_quit++;
c5aa993b 479 ninRegsPut ((char *) &nindy_regs);
c906108c
SS
480 immediate_quit--;
481}
482
c906108c
SS
483/* Copy LEN bytes to or from inferior's memory starting at MEMADDR
484 to debugger memory starting at MYADDR. Copy to inferior if
8c9cdfe8 485 SHOULD_WRITE is nonzero. Returns the length copied. */
c906108c
SS
486
487int
c5aa993b 488nindy_xfer_inferior_memory (memaddr, myaddr, len, should_write, target)
c906108c
SS
489 CORE_ADDR memaddr;
490 char *myaddr;
491 int len;
492 int should_write;
c5aa993b 493 struct target_ops *target; /* ignored */
c906108c 494{
8c9cdfe8
C
495 if (len <= 0)
496 return 0;
497 return dcache_xfer_memory (nindy_dcache, memaddr, myaddr,
498 len, should_write);
c906108c
SS
499}
500\f
501static void
fba45db2 502nindy_create_inferior (char *execfile, char *args, char **env)
c906108c
SS
503{
504 int entry_pt;
505 int pid;
506
507 if (args && *args)
508 error ("Can't pass arguments to remote NINDY process");
509
510 if (execfile == 0 || exec_bfd == 0)
511 error ("No executable file specified");
512
513 entry_pt = (int) bfd_get_start_address (exec_bfd);
514
515 pid = 42;
516
517 /* The "process" (board) is already stopped awaiting our commands, and
518 the program is already downloaded. We just set its PC and go. */
519
520 inferior_pid = pid; /* Needed for wait_for_inferior below */
521
522 clear_proceed_status ();
523
524 /* Tell wait_for_inferior that we've started a new process. */
525 init_wait_for_inferior ();
526
527 /* Set up the "saved terminal modes" of the inferior
528 based on what modes we are starting it with. */
529 target_terminal_init ();
530
531 /* Install inferior's terminal modes. */
532 target_terminal_inferior ();
533
534 /* insert_step_breakpoint (); FIXME, do we need this? */
535 /* Let 'er rip... */
c5aa993b 536 proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
c906108c
SS
537}
538
539static void
fba45db2 540reset_command (char *args, int from_tty)
c906108c
SS
541{
542 if (nindy_serial == NULL)
543 {
c5aa993b 544 error ("No target system to reset -- use 'target nindy' command.");
c906108c 545 }
c5aa993b 546 if (query ("Really reset the target system?", 0, 0))
c906108c
SS
547 {
548 SERIAL_SEND_BREAK (nindy_serial);
549 tty_flush (nindy_serial);
550 }
551}
552
553void
fba45db2 554nindy_kill (char *args, int from_tty)
c906108c 555{
c5aa993b 556 return; /* Ignore attempts to kill target system */
c906108c
SS
557}
558
559/* Clean up when a program exits.
560
561 The program actually lives on in the remote processor's RAM, and may be
562 run again without a download. Don't leave it full of breakpoint
563 instructions. */
564
565void
fba45db2 566nindy_mourn_inferior (void)
c906108c
SS
567{
568 remove_breakpoints ();
569 unpush_target (&nindy_ops);
570 generic_mourn_inferior (); /* Do all the proper things now */
571}
572\f
573/* Pass the args the way catch_errors wants them. */
574static int
fba45db2 575nindy_open_stub (char *arg)
c906108c
SS
576{
577 nindy_open (arg, 1);
578 return 1;
579}
580
581static void
fba45db2 582nindy_load (char *filename, int from_tty)
c906108c
SS
583{
584 asection *s;
585 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
586 all the work for us
c5aa993b 587 */
c906108c 588
c5aa993b 589 bfd *file = bfd_openr (filename, 0);
c906108c 590 if (!file)
c906108c 591 {
c5aa993b
JM
592 perror_with_name (filename);
593 return;
c906108c 594 }
c5aa993b
JM
595
596 if (!bfd_check_format (file, bfd_object))
597 {
598 error ("can't prove it's an object file\n");
599 return;
600 }
601
602 for (s = file->sections; s; s = s->next)
603 {
604 if (s->flags & SEC_LOAD)
605 {
606 char *buffer = xmalloc (s->_raw_size);
607 bfd_get_section_contents (file, s, buffer, 0, s->_raw_size);
608 printf ("Loading section %s, size %x vma %x\n",
609 s->name,
610 s->_raw_size,
611 s->vma);
612 ninMemPut (s->vma, buffer, s->_raw_size);
613 free (buffer);
614 }
615 }
616 bfd_close (file);
e99586d5
C
617
618 dcache_invd(nindy_dcache);
c906108c
SS
619}
620
621static int
fba45db2 622load_stub (char *arg)
c906108c
SS
623{
624 target_load (arg, 1);
625 return 1;
626}
627
628/* This routine is run as a hook, just before the main command loop is
629 entered. If gdb is configured for the i960, but has not had its
630 nindy target specified yet, this will loop prompting the user to do so.
631
632 Unlike the loop provided by Intel, we actually let the user get out
633 of this with a RETURN. This is useful when e.g. simply examining
634 an i960 object file on the host system. */
635
636void
fba45db2 637nindy_before_main_loop (void)
c906108c
SS
638{
639 char ttyname[100];
640 char *p, *p2;
641
c5aa993b 642 while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
c906108c 643 { /* remote tty not specified yet */
c5aa993b
JM
644 if (instream == stdin)
645 {
646 printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
647 gdb_flush (gdb_stdout);
c906108c 648 }
c5aa993b 649 fgets (ttyname, sizeof (ttyname) - 1, stdin);
c906108c 650
c5aa993b
JM
651 /* Strip leading and trailing whitespace */
652 for (p = ttyname; isspace (*p); p++)
653 {
654 ;
c906108c 655 }
c5aa993b
JM
656 if (*p == '\0')
657 {
658 return; /* User just hit spaces or return, wants out */
c906108c 659 }
c5aa993b
JM
660 for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++)
661 {
662 ;
c906108c 663 }
c5aa993b
JM
664 *p2 = '\0';
665 if (STREQ ("quit", p))
666 {
667 exit (1);
c906108c
SS
668 }
669
c5aa993b
JM
670 if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
671 {
672 /* Now that we have a tty open for talking to the remote machine,
673 download the executable file if one was specified. */
674 if (exec_bfd)
675 {
676 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
677 RETURN_MASK_ALL);
678 }
679 }
680 }
c906108c
SS
681}
682\f
683/* Define the target subroutine names */
684
c5aa993b 685struct target_ops nindy_ops;
c906108c 686
c5aa993b
JM
687static void
688init_nindy_ops (void)
c906108c 689{
c5aa993b
JM
690 nindy_ops.to_shortname = "nindy";
691 "Remote serial target in i960 NINDY-specific protocol",
692 nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\
c906108c
SS
693Specify the name of the device the serial line is connected to.\n\
694The speed (baud rate), whether to use the old NINDY protocol,\n\
695and whether to send a break on startup, are controlled by options\n\
c5aa993b
JM
696specified when you started GDB.";
697 nindy_ops.to_doc = "";
698 nindy_ops.to_open = nindy_open;
699 nindy_ops.to_close = nindy_close;
700 nindy_ops.to_attach = 0;
c906108c
SS
701 nindy_ops.to_post_attach = NULL;
702 nindy_ops.to_require_attach = NULL;
c5aa993b 703 nindy_ops.to_detach = nindy_detach;
c906108c 704 nindy_ops.to_require_detach = NULL;
c5aa993b
JM
705 nindy_ops.to_resume = nindy_resume;
706 nindy_ops.to_wait = nindy_wait;
c906108c 707 nindy_ops.to_post_wait = NULL;
c5aa993b
JM
708 nindy_ops.to_fetch_registers = nindy_fetch_registers;
709 nindy_ops.to_store_registers = nindy_store_registers;
710 nindy_ops.to_prepare_to_store = nindy_prepare_to_store;
711 nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory;
712 nindy_ops.to_files_info = nindy_files_info;
713 nindy_ops.to_insert_breakpoint = memory_insert_breakpoint;
714 nindy_ops.to_remove_breakpoint = memory_remove_breakpoint;
715 nindy_ops.to_terminal_init = 0;
716 nindy_ops.to_terminal_inferior = 0;
717 nindy_ops.to_terminal_ours_for_output = 0;
718 nindy_ops.to_terminal_ours = 0;
719 nindy_ops.to_terminal_info = 0; /* Terminal crud */
720 nindy_ops.to_kill = nindy_kill;
721 nindy_ops.to_load = nindy_load;
722 nindy_ops.to_lookup_symbol = 0; /* lookup_symbol */
723 nindy_ops.to_create_inferior = nindy_create_inferior;
c906108c
SS
724 nindy_ops.to_post_startup_inferior = NULL;
725 nindy_ops.to_acknowledge_created_inferior = NULL;
726 nindy_ops.to_clone_and_follow_inferior = NULL;
727 nindy_ops.to_post_follow_inferior_by_clone = NULL;
728 nindy_ops.to_insert_fork_catchpoint = NULL;
729 nindy_ops.to_remove_fork_catchpoint = NULL;
730 nindy_ops.to_insert_vfork_catchpoint = NULL;
731 nindy_ops.to_remove_vfork_catchpoint = NULL;
732 nindy_ops.to_has_forked = NULL;
733 nindy_ops.to_has_vforked = NULL;
734 nindy_ops.to_can_follow_vfork_prior_to_exec = NULL;
735 nindy_ops.to_post_follow_vfork = NULL;
736 nindy_ops.to_insert_exec_catchpoint = NULL;
737 nindy_ops.to_remove_exec_catchpoint = NULL;
738 nindy_ops.to_has_execd = NULL;
739 nindy_ops.to_reported_exec_events_per_exec_call = NULL;
740 nindy_ops.to_has_exited = NULL;
c5aa993b
JM
741 nindy_ops.to_mourn_inferior = nindy_mourn_inferior;
742 nindy_ops.to_can_run = 0; /* can_run */
743 nindy_ops.to_notice_signals = 0; /* notice_signals */
744 nindy_ops.to_thread_alive = 0; /* to_thread_alive */
745 nindy_ops.to_stop = 0; /* to_stop */
c906108c
SS
746 nindy_ops.to_pid_to_exec_file = NULL;
747 nindy_ops.to_core_file_to_sym_file = NULL;
c5aa993b
JM
748 nindy_ops.to_stratum = process_stratum;
749 nindy_ops.DONT_USE = 0; /* next */
750 nindy_ops.to_has_all_memory = 1;
751 nindy_ops.to_has_memory = 1;
752 nindy_ops.to_has_stack = 1;
753 nindy_ops.to_has_registers = 1;
754 nindy_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */
755 nindy_ops.to_sections = 0;
756 nindy_ops.to_sections_end = 0; /* Section pointers */
757 nindy_ops.to_magic = OPS_MAGIC; /* Always the last thing */
c906108c
SS
758}
759
760void
fba45db2 761_initialize_nindy (void)
c906108c 762{
c5aa993b 763 init_nindy_ops ();
c906108c
SS
764 add_target (&nindy_ops);
765 add_com ("reset", class_obscure, reset_command,
766 "Send a 'break' to the remote target system.\n\
767Only useful if the target has been equipped with a circuit\n\
768to perform a hard reset when a break is detected.");
769}
This page took 0.122869 seconds and 4 git commands to generate.