Update copyright year in most headers.
[external/binutils.git] / gdb / remote-sim.c
1 /* Generic remote debugging interface for simulators.
2
3    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4    2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
6    Contributed by Cygnus Support.
7    Steve Chamberlain (sac@cygnus.com).
8
9    This file is part of GDB.
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
24 #include "defs.h"
25 #include "inferior.h"
26 #include "value.h"
27 #include "gdb_string.h"
28 #include <ctype.h>
29 #include <fcntl.h>
30 #include <signal.h>
31 #include <setjmp.h>
32 #include <errno.h>
33 #include "terminal.h"
34 #include "target.h"
35 #include "gdbcore.h"
36 #include "gdb/callback.h"
37 #include "gdb/remote-sim.h"
38 #include "command.h"
39 #include "regcache.h"
40 #include "gdb_assert.h"
41 #include "sim-regno.h"
42 #include "arch-utils.h"
43 #include "readline/readline.h"
44 #include "gdbthread.h"
45
46 /* Prototypes */
47
48 extern void _initialize_remote_sim (void);
49
50 static void dump_mem (char *buf, int len);
51
52 static void init_callbacks (void);
53
54 static void end_callbacks (void);
55
56 static int gdb_os_write_stdout (host_callback *, const char *, int);
57
58 static void gdb_os_flush_stdout (host_callback *);
59
60 static int gdb_os_write_stderr (host_callback *, const char *, int);
61
62 static void gdb_os_flush_stderr (host_callback *);
63
64 static int gdb_os_poll_quit (host_callback *);
65
66 /* printf_filtered is depreciated */
67 static void gdb_os_printf_filtered (host_callback *, const char *, ...);
68
69 static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
70
71 static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
72
73 static void gdb_os_error (host_callback *, const char *, ...) ATTR_NORETURN;
74
75 static void gdbsim_kill (struct target_ops *);
76
77 static void gdbsim_load (char *prog, int fromtty);
78
79 static void gdbsim_open (char *args, int from_tty);
80
81 static void gdbsim_close (int quitting);
82
83 static void gdbsim_detach (struct target_ops *ops, char *args, int from_tty);
84
85 static void gdbsim_prepare_to_store (struct regcache *regcache);
86
87 static void gdbsim_files_info (struct target_ops *target);
88
89 static void gdbsim_mourn_inferior (struct target_ops *target);
90
91 static void gdbsim_stop (ptid_t ptid);
92
93 void simulator_command (char *args, int from_tty);
94
95 /* Naming convention:
96
97    sim_* are the interface to the simulator (see remote-sim.h).
98    gdbsim_* are stuff which is internal to gdb.  */
99
100 /* Forward data declarations */
101 extern struct target_ops gdbsim_ops;
102
103 static int program_loaded = 0;
104
105 /* We must keep track of whether the simulator has been opened or not because
106    GDB can call a target's close routine twice, but sim_close doesn't allow
107    this.  We also need to record the result of sim_open so we can pass it
108    back to the other sim_foo routines.  */
109 static SIM_DESC gdbsim_desc = 0;
110
111 /* This is the ptid we use while we're connected to the simulator.
112    Its value is arbitrary, as the simulator target don't have a notion
113    or processes or threads, but we need something non-null to place in
114    inferior_ptid.  */
115 static ptid_t remote_sim_ptid;
116
117 static void
118 dump_mem (char *buf, int len)
119 {
120   if (len <= 8)
121     {
122       if (len == 8 || len == 4)
123         {
124           long l[2];
125           memcpy (l, buf, len);
126           printf_filtered ("\t0x%lx", l[0]);
127           if (len == 8)
128             printf_filtered (" 0x%lx", l[1]);
129           printf_filtered ("\n");
130         }
131       else
132         {
133           int i;
134           printf_filtered ("\t");
135           for (i = 0; i < len; i++)
136             printf_filtered ("0x%x ", buf[i]);
137           printf_filtered ("\n");
138         }
139     }
140 }
141
142 static host_callback gdb_callback;
143 static int callbacks_initialized = 0;
144
145 /* Initialize gdb_callback.  */
146
147 static void
148 init_callbacks (void)
149 {
150   if (!callbacks_initialized)
151     {
152       gdb_callback = default_callback;
153       gdb_callback.init (&gdb_callback);
154       gdb_callback.write_stdout = gdb_os_write_stdout;
155       gdb_callback.flush_stdout = gdb_os_flush_stdout;
156       gdb_callback.write_stderr = gdb_os_write_stderr;
157       gdb_callback.flush_stderr = gdb_os_flush_stderr;
158       gdb_callback.printf_filtered = gdb_os_printf_filtered;
159       gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
160       gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
161       gdb_callback.error = gdb_os_error;
162       gdb_callback.poll_quit = gdb_os_poll_quit;
163       gdb_callback.magic = HOST_CALLBACK_MAGIC;
164       callbacks_initialized = 1;
165     }
166 }
167
168 /* Release callbacks (free resources used by them).  */
169
170 static void
171 end_callbacks (void)
172 {
173   if (callbacks_initialized)
174     {
175       gdb_callback.shutdown (&gdb_callback);
176       callbacks_initialized = 0;
177     }
178 }
179
180 /* GDB version of os_write_stdout callback.  */
181
182 static int
183 gdb_os_write_stdout (host_callback *p, const char *buf, int len)
184 {
185   int i;
186   char b[2];
187
188   ui_file_write (gdb_stdtarg, buf, len);
189   return len;
190 }
191
192 /* GDB version of os_flush_stdout callback.  */
193
194 static void
195 gdb_os_flush_stdout (host_callback *p)
196 {
197   gdb_flush (gdb_stdtarg);
198 }
199
200 /* GDB version of os_write_stderr callback.  */
201
202 static int
203 gdb_os_write_stderr (host_callback *p, const char *buf, int len)
204 {
205   int i;
206   char b[2];
207
208   for (i = 0; i < len; i++)
209     {
210       b[0] = buf[i];
211       b[1] = 0;
212       fputs_unfiltered (b, gdb_stdtargerr);
213     }
214   return len;
215 }
216
217 /* GDB version of os_flush_stderr callback.  */
218
219 static void
220 gdb_os_flush_stderr (host_callback *p)
221 {
222   gdb_flush (gdb_stdtargerr);
223 }
224
225 /* GDB version of printf_filtered callback.  */
226
227 static void
228 gdb_os_printf_filtered (host_callback * p, const char *format,...)
229 {
230   va_list args;
231   va_start (args, format);
232
233   vfprintf_filtered (gdb_stdout, format, args);
234
235   va_end (args);
236 }
237
238 /* GDB version of error vprintf_filtered.  */
239
240 static void
241 gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
242 {
243   vfprintf_filtered (gdb_stdout, format, ap);
244 }
245
246 /* GDB version of error evprintf_filtered.  */
247
248 static void
249 gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
250 {
251   vfprintf_filtered (gdb_stderr, format, ap);
252 }
253
254 /* GDB version of error callback.  */
255
256 static void
257 gdb_os_error (host_callback * p, const char *format, ...)
258 {
259   va_list args;
260   va_start (args, format);
261   verror (format, args);
262   va_end (args);
263 }
264
265 int
266 one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
267 {
268   /* Only makes sense to supply raw registers.  */
269   gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
270   return regnum;
271 }
272
273 static void
274 gdbsim_fetch_register (struct target_ops *ops,
275                        struct regcache *regcache, int regno)
276 {
277   struct gdbarch *gdbarch = get_regcache_arch (regcache);
278   if (regno == -1)
279     {
280       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
281         gdbsim_fetch_register (ops, regcache, regno);
282       return;
283     }
284
285   switch (gdbarch_register_sim_regno (gdbarch, regno))
286     {
287     case LEGACY_SIM_REGNO_IGNORE:
288       break;
289     case SIM_REGNO_DOES_NOT_EXIST:
290       {
291         /* For moment treat a `does not exist' register the same way
292            as an ``unavailable'' register.  */
293         char buf[MAX_REGISTER_SIZE];
294         int nr_bytes;
295         memset (buf, 0, MAX_REGISTER_SIZE);
296         regcache_raw_supply (regcache, regno, buf);
297         break;
298       }
299       
300     default:
301       {
302         static int warn_user = 1;
303         char buf[MAX_REGISTER_SIZE];
304         int nr_bytes;
305         gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
306         memset (buf, 0, MAX_REGISTER_SIZE);
307         nr_bytes = sim_fetch_register (gdbsim_desc,
308                                        gdbarch_register_sim_regno
309                                          (gdbarch, regno),
310                                        buf,
311                                        register_size (gdbarch, regno));
312         if (nr_bytes > 0
313             && nr_bytes != register_size (gdbarch, regno) && warn_user)
314           {
315             fprintf_unfiltered (gdb_stderr,
316                                 "Size of register %s (%d/%d) incorrect (%d instead of %d))",
317                                 gdbarch_register_name (gdbarch, regno),
318                                 regno,
319                                 gdbarch_register_sim_regno
320                                   (gdbarch, regno),
321                                 nr_bytes, register_size (gdbarch, regno));
322             warn_user = 0;
323           }
324         /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
325            indicating that GDB and the SIM have different ideas about
326            which registers are fetchable.  */
327         /* Else if (nr_bytes < 0): an old simulator, that doesn't
328            think to return the register size.  Just assume all is ok.  */
329         regcache_raw_supply (regcache, regno, buf);
330         if (remote_debug)
331           {
332             printf_filtered ("gdbsim_fetch_register: %d", regno);
333             /* FIXME: We could print something more intelligible.  */
334             dump_mem (buf, register_size (gdbarch, regno));
335           }
336         break;
337       }
338     }
339 }
340
341
342 static void
343 gdbsim_store_register (struct target_ops *ops,
344                        struct regcache *regcache, int regno)
345 {
346   struct gdbarch *gdbarch = get_regcache_arch (regcache);
347   if (regno == -1)
348     {
349       for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
350         gdbsim_store_register (ops, regcache, regno);
351       return;
352     }
353   else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
354     {
355       char tmp[MAX_REGISTER_SIZE];
356       int nr_bytes;
357       regcache_cooked_read (regcache, regno, tmp);
358       nr_bytes = sim_store_register (gdbsim_desc,
359                                      gdbarch_register_sim_regno
360                                        (gdbarch, regno),
361                                      tmp, register_size (gdbarch, regno));
362       if (nr_bytes > 0 && nr_bytes != register_size (gdbarch, regno))
363         internal_error (__FILE__, __LINE__,
364                         _("Register size different to expected"));
365       /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
366          indicating that GDB and the SIM have different ideas about
367          which registers are fetchable.  */
368       if (remote_debug)
369         {
370           printf_filtered ("gdbsim_store_register: %d", regno);
371           /* FIXME: We could print something more intelligible.  */
372           dump_mem (tmp, register_size (gdbarch, regno));
373         }
374     }
375 }
376
377 /* Kill the running program.  This may involve closing any open files
378    and releasing other resources acquired by the simulated program.  */
379
380 static void
381 gdbsim_kill (struct target_ops *ops)
382 {
383   if (remote_debug)
384     printf_filtered ("gdbsim_kill\n");
385
386   /* There is no need to `kill' running simulator - the simulator is
387      not running.  Mourning it is enough.  */
388   target_mourn_inferior ();
389 }
390
391 /* Load an executable file into the target process.  This is expected to
392    not only bring new code into the target process, but also to update
393    GDB's symbol tables to match.  */
394
395 static void
396 gdbsim_load (char *args, int fromtty)
397 {
398   char **argv;
399   char *prog;
400
401   if (args == NULL)
402       error_no_arg (_("program to load"));
403
404   argv = gdb_buildargv (args);
405   make_cleanup_freeargv (argv);
406
407   prog = tilde_expand (argv[0]);
408
409   if (argv[1] != NULL)
410     error (_("GDB sim does not yet support a load offset."));
411
412   if (remote_debug)
413     printf_filtered ("gdbsim_load: prog \"%s\"\n", prog);
414
415   /* FIXME: We will print two messages on error.
416      Need error to either not print anything if passed NULL or need
417      another routine that doesn't take any arguments.  */
418   if (sim_load (gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
419     error (_("unable to load program"));
420
421   /* FIXME: If a load command should reset the targets registers then
422      a call to sim_create_inferior() should go here. */
423
424   program_loaded = 1;
425 }
426
427
428 /* Start an inferior process and set inferior_ptid to its pid.
429    EXEC_FILE is the file to run.
430    ARGS is a string containing the arguments to the program.
431    ENV is the environment vector to pass.  Errors reported with error().
432    On VxWorks and various standalone systems, we ignore exec_file.  */
433 /* This is called not only when we first attach, but also when the
434    user types "run" after having attached.  */
435
436 static void
437 gdbsim_create_inferior (struct target_ops *target, char *exec_file, char *args,
438                         char **env, int from_tty)
439 {
440   int len;
441   char *arg_buf, **argv;
442
443   if (exec_file == 0 || exec_bfd == 0)
444     warning (_("No executable file specified."));
445   if (!program_loaded)
446     warning (_("No program loaded."));
447
448   if (remote_debug)
449     printf_filtered ("gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
450                      (exec_file ? exec_file : "(NULL)"),
451                      args);
452
453   if (ptid_equal (inferior_ptid, remote_sim_ptid))
454     gdbsim_kill (target);
455   remove_breakpoints ();
456   init_wait_for_inferior ();
457
458   if (exec_file != NULL)
459     {
460       len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
461       arg_buf = (char *) alloca (len);
462       arg_buf[0] = '\0';
463       strcat (arg_buf, exec_file);
464       strcat (arg_buf, " ");
465       strcat (arg_buf, args);
466       argv = gdb_buildargv (arg_buf);
467       make_cleanup_freeargv (argv);
468     }
469   else
470     argv = NULL;
471   sim_create_inferior (gdbsim_desc, exec_bfd, argv, env);
472
473   inferior_ptid = remote_sim_ptid;
474   inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
475   add_thread_silent (inferior_ptid);
476
477   insert_breakpoints ();        /* Needed to get correct instruction in cache */
478
479   clear_proceed_status ();
480 }
481
482 /* The open routine takes the rest of the parameters from the command,
483    and (if successful) pushes a new target onto the stack.
484    Targets should supply this routine, if only to provide an error message.  */
485 /* Called when selecting the simulator. EG: (gdb) target sim name.  */
486
487 static void
488 gdbsim_open (char *args, int from_tty)
489 {
490   int len;
491   char *arg_buf;
492   char **argv;
493
494   if (remote_debug)
495     printf_filtered ("gdbsim_open: args \"%s\"\n", args ? args : "(null)");
496
497   /* Remove current simulator if one exists.  Only do this if the simulator
498      has been opened because sim_close requires it.
499      This is important because the call to push_target below will cause
500      sim_close to be called if the simulator is already open, but push_target
501      is called after sim_open!  We can't move the call to push_target before
502      the call to sim_open because sim_open may invoke `error'.  */
503   if (gdbsim_desc != NULL)
504     unpush_target (&gdbsim_ops);
505
506   len = (7 + 1                  /* gdbsim */
507          + strlen (" -E little")
508          + strlen (" --architecture=xxxxxxxxxx")
509          + (args ? strlen (args) : 0)
510          + 50) /* slack */ ;
511   arg_buf = (char *) alloca (len);
512   strcpy (arg_buf, "gdbsim");   /* 7 */
513   /* Specify the byte order for the target when it is explicitly
514      specified by the user (not auto detected). */
515   switch (selected_byte_order ())
516     {
517     case BFD_ENDIAN_BIG:
518       strcat (arg_buf, " -E big");
519       break;
520     case BFD_ENDIAN_LITTLE:
521       strcat (arg_buf, " -E little");
522       break;
523     case BFD_ENDIAN_UNKNOWN:
524       break;
525     }
526   /* Specify the architecture of the target when it has been
527      explicitly specified */
528   if (selected_architecture_name () != NULL)
529     {
530       strcat (arg_buf, " --architecture=");
531       strcat (arg_buf, selected_architecture_name ());
532     }
533   /* finally, any explicit args */
534   if (args)
535     {
536       strcat (arg_buf, " ");    /* 1 */
537       strcat (arg_buf, args);
538     }
539   argv = gdb_buildargv (arg_buf);
540   make_cleanup_freeargv (argv);
541
542   init_callbacks ();
543   gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, argv);
544
545   if (gdbsim_desc == 0)
546     error (_("unable to create simulator instance"));
547
548   push_target (&gdbsim_ops);
549   printf_filtered ("Connected to the simulator.\n");
550
551   /* There's nothing running after "target sim" or "load"; not until
552      "run".  */
553   inferior_ptid = null_ptid;
554 }
555
556 /* Does whatever cleanup is required for a target that we are no longer
557    going to be calling.  Argument says whether we are quitting gdb and
558    should not get hung in case of errors, or whether we want a clean
559    termination even if it takes a while.  This routine is automatically
560    always called just before a routine is popped off the target stack.
561    Closing file descriptors and freeing memory are typical things it should
562    do.  */
563 /* Close out all files and local state before this target loses control. */
564
565 static void
566 gdbsim_close (int quitting)
567 {
568   if (remote_debug)
569     printf_filtered ("gdbsim_close: quitting %d\n", quitting);
570
571   program_loaded = 0;
572
573   if (gdbsim_desc != NULL)
574     {
575       sim_close (gdbsim_desc, quitting);
576       gdbsim_desc = NULL;
577     }
578
579   end_callbacks ();
580   generic_mourn_inferior ();
581   delete_thread_silent (remote_sim_ptid);
582   delete_inferior_silent (ptid_get_pid (remote_sim_ptid));
583 }
584
585 /* Takes a program previously attached to and detaches it.
586    The program may resume execution (some targets do, some don't) and will
587    no longer stop on signals, etc.  We better not have left any breakpoints
588    in the program or it'll die when it hits one.  ARGS is arguments
589    typed by the user (e.g. a signal to send the process).  FROM_TTY
590    says whether to be verbose or not.  */
591 /* Terminate the open connection to the remote debugger.
592    Use this when you want to detach and do something else with your gdb.  */
593
594 static void
595 gdbsim_detach (struct target_ops *ops, char *args, int from_tty)
596 {
597   if (remote_debug)
598     printf_filtered ("gdbsim_detach: args \"%s\"\n", args);
599
600   pop_target ();                /* calls gdbsim_close to do the real work */
601   if (from_tty)
602     printf_filtered ("Ending simulator %s debugging\n", target_shortname);
603 }
604
605 /* Resume execution of the target process.  STEP says whether to single-step
606    or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
607    to the target, or zero for no signal.  */
608
609 static enum target_signal resume_siggnal;
610 static int resume_step;
611
612 static void
613 gdbsim_resume (struct target_ops *ops,
614                ptid_t ptid, int step, enum target_signal siggnal)
615 {
616   if (!ptid_equal (inferior_ptid, remote_sim_ptid))
617     error (_("The program is not being run."));
618
619   if (remote_debug)
620     printf_filtered ("gdbsim_resume: step %d, signal %d\n", step, siggnal);
621
622   resume_siggnal = siggnal;
623   resume_step = step;
624 }
625
626 /* Notify the simulator of an asynchronous request to stop.
627
628    The simulator shall ensure that the stop request is eventually
629    delivered to the simulator.  If the call is made while the
630    simulator is not running then the stop request is processed when
631    the simulator is next resumed.
632
633    For simulators that do not support this operation, just abort */
634
635 static void
636 gdbsim_stop (ptid_t ptid)
637 {
638   if (!sim_stop (gdbsim_desc))
639     {
640       quit ();
641     }
642 }
643
644 /* GDB version of os_poll_quit callback.
645    Taken from gdb/util.c - should be in a library.  */
646
647 static int
648 gdb_os_poll_quit (host_callback *p)
649 {
650   if (deprecated_ui_loop_hook != NULL)
651     deprecated_ui_loop_hook (0);
652
653   if (quit_flag)                /* gdb's idea of quit */
654     {
655       quit_flag = 0;            /* we've stolen it */
656       return 1;
657     }
658   else if (immediate_quit)
659     {
660       return 1;
661     }
662   return 0;
663 }
664
665 /* Wait for inferior process to do something.  Return pid of child,
666    or -1 in case of error; store status through argument pointer STATUS,
667    just as `wait' would. */
668
669 static void
670 gdbsim_cntrl_c (int signo)
671 {
672   gdbsim_stop (remote_sim_ptid);
673 }
674
675 static ptid_t
676 gdbsim_wait (struct target_ops *ops,
677              ptid_t ptid, struct target_waitstatus *status, int options)
678 {
679   static RETSIGTYPE (*prev_sigint) ();
680   int sigrc = 0;
681   enum sim_stop reason = sim_running;
682
683   if (remote_debug)
684     printf_filtered ("gdbsim_wait\n");
685
686 #if defined (HAVE_SIGACTION) && defined (SA_RESTART)
687   {
688     struct sigaction sa, osa;
689     sa.sa_handler = gdbsim_cntrl_c;
690     sigemptyset (&sa.sa_mask);
691     sa.sa_flags = 0;
692     sigaction (SIGINT, &sa, &osa);
693     prev_sigint = osa.sa_handler;
694   }
695 #else
696   prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
697 #endif
698   sim_resume (gdbsim_desc, resume_step, resume_siggnal);
699   signal (SIGINT, prev_sigint);
700   resume_step = 0;
701
702   sim_stop_reason (gdbsim_desc, &reason, &sigrc);
703
704   switch (reason)
705     {
706     case sim_exited:
707       status->kind = TARGET_WAITKIND_EXITED;
708       status->value.integer = sigrc;
709       break;
710     case sim_stopped:
711       switch (sigrc)
712         {
713         case TARGET_SIGNAL_ABRT:
714           quit ();
715           break;
716         case TARGET_SIGNAL_INT:
717         case TARGET_SIGNAL_TRAP:
718         default:
719           status->kind = TARGET_WAITKIND_STOPPED;
720           status->value.sig = sigrc;
721           break;
722         }
723       break;
724     case sim_signalled:
725       status->kind = TARGET_WAITKIND_SIGNALLED;
726       status->value.sig = sigrc;
727       break;
728     case sim_running:
729     case sim_polling:
730       /* FIXME: Is this correct? */
731       break;
732     }
733
734   return inferior_ptid;
735 }
736
737 /* Get ready to modify the registers array.  On machines which store
738    individual registers, this doesn't need to do anything.  On machines
739    which store all the registers in one fell swoop, this makes sure
740    that registers contains all the registers from the program being
741    debugged.  */
742
743 static void
744 gdbsim_prepare_to_store (struct regcache *regcache)
745 {
746   /* Do nothing, since we can store individual regs */
747 }
748
749 /* Transfer LEN bytes between GDB address MYADDR and target address
750    MEMADDR.  If WRITE is non-zero, transfer them to the target,
751    otherwise transfer them from the target.  TARGET is unused.
752
753    Returns the number of bytes transferred. */
754
755 static int
756 gdbsim_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
757                              int write, struct mem_attrib *attrib,
758                              struct target_ops *target)
759 {
760   /* If no program is running yet, then ignore the simulator for
761      memory.  Pass the request down to the next target, hopefully
762      an exec file.  */
763   if (!target_has_execution)
764     return 0;
765
766   if (!program_loaded)
767     error (_("No program loaded."));
768
769   if (remote_debug)
770     {
771       /* FIXME: Send to something other than STDOUT? */
772       printf_filtered ("gdbsim_xfer_inferior_memory: myaddr 0x");
773       gdb_print_host_address (myaddr, gdb_stdout);
774       printf_filtered (", memaddr %s, len %d, write %d\n",
775                        paddress (target_gdbarch, memaddr), len, write);
776       if (remote_debug && write)
777         dump_mem (myaddr, len);
778     }
779
780   if (write)
781     {
782       len = sim_write (gdbsim_desc, memaddr, myaddr, len);
783     }
784   else
785     {
786       len = sim_read (gdbsim_desc, memaddr, myaddr, len);
787       if (remote_debug && len > 0)
788         dump_mem (myaddr, len);
789     }
790   return len;
791 }
792
793 static void
794 gdbsim_files_info (struct target_ops *target)
795 {
796   char *file = "nothing";
797
798   if (exec_bfd)
799     file = bfd_get_filename (exec_bfd);
800
801   if (remote_debug)
802     printf_filtered ("gdbsim_files_info: file \"%s\"\n", file);
803
804   if (exec_bfd)
805     {
806       printf_filtered ("\tAttached to %s running program %s\n",
807                        target_shortname, file);
808       sim_info (gdbsim_desc, 0);
809     }
810 }
811
812 /* Clear the simulator's notion of what the break points are.  */
813
814 static void
815 gdbsim_mourn_inferior (struct target_ops *target)
816 {
817   if (remote_debug)
818     printf_filtered ("gdbsim_mourn_inferior:\n");
819
820   remove_breakpoints ();
821   generic_mourn_inferior ();
822   delete_thread_silent (remote_sim_ptid);
823 }
824
825 /* Pass the command argument through to the simulator verbatim.  The
826    simulator must do any command interpretation work.  */
827
828 void
829 simulator_command (char *args, int from_tty)
830 {
831   if (gdbsim_desc == NULL)
832     {
833
834       /* PREVIOUSLY: The user may give a command before the simulator
835          is opened. [...] (??? assuming of course one wishes to
836          continue to allow commands to be sent to unopened simulators,
837          which isn't entirely unreasonable). */
838
839       /* The simulator is a builtin abstraction of a remote target.
840          Consistent with that model, access to the simulator, via sim
841          commands, is restricted to the period when the channel to the
842          simulator is open. */
843
844       error (_("Not connected to the simulator target"));
845     }
846
847   sim_do_command (gdbsim_desc, args);
848
849   /* Invalidate the register cache, in case the simulator command does
850      something funny. */
851   registers_changed ();
852 }
853
854 /* Check to see if a thread is still alive.  */
855
856 static int
857 gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
858 {
859   if (ptid_equal (ptid, remote_sim_ptid))
860     /* The simulators' task is always alive.  */
861     return 1;
862
863   return 0;
864 }
865
866 /* Convert a thread ID to a string.  Returns the string in a static
867    buffer.  */
868
869 static char *
870 gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
871 {
872   static char buf[64];
873
874   if (ptid_equal (remote_sim_ptid, ptid))
875     {
876       xsnprintf (buf, sizeof buf, "Thread <main>");
877       return buf;
878     }
879
880   return normal_pid_to_str (ptid);
881 }
882
883 /* Define the target subroutine names */
884
885 struct target_ops gdbsim_ops;
886
887 static void
888 init_gdbsim_ops (void)
889 {
890   gdbsim_ops.to_shortname = "sim";
891   gdbsim_ops.to_longname = "simulator";
892   gdbsim_ops.to_doc = "Use the compiled-in simulator.";
893   gdbsim_ops.to_open = gdbsim_open;
894   gdbsim_ops.to_close = gdbsim_close;
895   gdbsim_ops.to_detach = gdbsim_detach;
896   gdbsim_ops.to_resume = gdbsim_resume;
897   gdbsim_ops.to_wait = gdbsim_wait;
898   gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
899   gdbsim_ops.to_store_registers = gdbsim_store_register;
900   gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
901   gdbsim_ops.deprecated_xfer_memory = gdbsim_xfer_inferior_memory;
902   gdbsim_ops.to_files_info = gdbsim_files_info;
903   gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
904   gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
905   gdbsim_ops.to_kill = gdbsim_kill;
906   gdbsim_ops.to_load = gdbsim_load;
907   gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
908   gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
909   gdbsim_ops.to_stop = gdbsim_stop;
910   gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
911   gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
912   gdbsim_ops.to_stratum = process_stratum;
913   gdbsim_ops.to_has_all_memory = default_child_has_all_memory;
914   gdbsim_ops.to_has_memory = default_child_has_memory;
915   gdbsim_ops.to_has_stack = default_child_has_stack;
916   gdbsim_ops.to_has_registers = default_child_has_registers;
917   gdbsim_ops.to_has_execution = default_child_has_execution;
918   gdbsim_ops.to_magic = OPS_MAGIC;
919 }
920
921 void
922 _initialize_remote_sim (void)
923 {
924   init_gdbsim_ops ();
925   add_target (&gdbsim_ops);
926
927   add_com ("sim", class_obscure, simulator_command,
928            _("Send a command to the simulator."));
929
930   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
931      isn't 0.  */
932   remote_sim_ptid = ptid_build (42000, 0, 42000);
933 }