Improve MSP430 section placement.
[deliverable/binutils-gdb.git] / gdb / remote-sim.c
CommitLineData
c906108c 1/* Generic remote debugging interface for simulators.
0a65a603 2
61baf725 3 Copyright (C) 1993-2017 Free Software Foundation, Inc.
0a65a603 4
c906108c
SS
5 Contributed by Cygnus Support.
6 Steve Chamberlain (sac@cygnus.com).
7
c5aa993b 8 This file is part of GDB.
c906108c 9
c5aa993b
JM
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
a9762ec7 12 the Free Software Foundation; either version 3 of the License, or
c5aa993b 13 (at your option) any later version.
c906108c 14
c5aa993b
JM
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
c906108c 19
c5aa993b 20 You should have received a copy of the GNU General Public License
a9762ec7 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
22
23#include "defs.h"
23bf70af 24#include "gdb_bfd.h"
c906108c 25#include "inferior.h"
45741a9c 26#include "infrun.h"
c906108c 27#include "value.h"
c906108c
SS
28#include <ctype.h>
29#include <fcntl.h>
30#include <signal.h>
31#include <setjmp.h>
c906108c
SS
32#include "terminal.h"
33#include "target.h"
34#include "gdbcore.h"
3c25f8c7
AC
35#include "gdb/callback.h"
36#include "gdb/remote-sim.h"
c906108c 37#include "command.h"
4e052eda 38#include "regcache.h"
8238d0bf 39#include "sim-regno.h"
a8cf2722 40#include "arch-utils.h"
1986bccd 41#include "readline/readline.h"
9de2bdd7 42#include "gdbthread.h"
a4d1e79a 43#include "common/byte-vector.h"
c906108c
SS
44
45/* Prototypes */
46
a14ed312 47extern void _initialize_remote_sim (void);
392a587b 48
a14ed312 49static void init_callbacks (void);
c906108c 50
a14ed312 51static void end_callbacks (void);
c906108c 52
a14ed312 53static int gdb_os_write_stdout (host_callback *, const char *, int);
c906108c 54
a14ed312 55static void gdb_os_flush_stdout (host_callback *);
c906108c 56
a14ed312 57static int gdb_os_write_stderr (host_callback *, const char *, int);
c906108c 58
a14ed312 59static void gdb_os_flush_stderr (host_callback *);
c906108c 60
a14ed312 61static int gdb_os_poll_quit (host_callback *);
c906108c 62
0df8b418 63/* printf_filtered is depreciated. */
a14ed312 64static void gdb_os_printf_filtered (host_callback *, const char *, ...);
c906108c 65
a14ed312 66static void gdb_os_vprintf_filtered (host_callback *, const char *, va_list);
c906108c 67
a14ed312 68static void gdb_os_evprintf_filtered (host_callback *, const char *, va_list);
c906108c 69
c25c4a8b
JK
70static void gdb_os_error (host_callback *, const char *, ...)
71 ATTRIBUTE_NORETURN;
c906108c 72
7d85a9c0 73static void gdbsim_kill (struct target_ops *);
c906108c 74
9cbe5fff
TT
75static void gdbsim_load (struct target_ops *self, const char *prog,
76 int fromtty);
c906108c 77
74228e77 78static void gdbsim_open (const char *args, int from_tty);
c906108c 79
de90e03d 80static void gdbsim_close (struct target_ops *self);
c906108c 81
8ca5801b
JB
82static void gdbsim_detach (struct target_ops *ops, const char *args,
83 int from_tty);
c906108c 84
f32dbf8c
MM
85static void gdbsim_prepare_to_store (struct target_ops *self,
86 struct regcache *regcache);
c906108c 87
a14ed312 88static void gdbsim_files_info (struct target_ops *target);
c906108c 89
3c8b2eda 90static void gdbsim_mourn_inferior (struct target_ops *target);
c906108c 91
bfedc46a 92static void gdbsim_interrupt (struct target_ops *self, ptid_t ptid);
c906108c 93
a14ed312 94void simulator_command (char *args, int from_tty);
c906108c
SS
95
96/* Naming convention:
97
98 sim_* are the interface to the simulator (see remote-sim.h).
99 gdbsim_* are stuff which is internal to gdb. */
100
101/* Forward data declarations */
102extern struct target_ops gdbsim_ops;
103
db04efe6
KB
104static const struct inferior_data *sim_inferior_data_key;
105
106/* Simulator-specific, per-inferior state. */
107struct sim_inferior_data {
108 /* Flag which indicates whether or not the program has been loaded. */
109 int program_loaded;
110
111 /* Simulator descriptor for this inferior. */
112 SIM_DESC gdbsim_desc;
113
114 /* This is the ptid we use for this particular simulator instance. Its
115 value is somewhat arbitrary, as the simulator target don't have a
116 notion of tasks or threads, but we need something non-null to place
117 in inferior_ptid. For simulators which permit multiple instances,
118 we also need a unique identifier to use for each inferior. */
119 ptid_t remote_sim_ptid;
120
121 /* Signal with which to resume. */
2ea28649 122 enum gdb_signal resume_siggnal;
db04efe6
KB
123
124 /* Flag which indicates whether resume should step or not. */
125 int resume_step;
126};
127
128/* Flag indicating the "open" status of this module. It's set to 1
129 in gdbsim_open() and 0 in gdbsim_close(). */
130static int gdbsim_is_open = 0;
131
132/* Value of the next pid to allocate for an inferior. As indicated
133 elsewhere, its initial value is somewhat arbitrary; it's critical
134 though that it's not zero or negative. */
135static int next_pid;
136#define INITIAL_PID 42000
137
138/* Argument list to pass to sim_open(). It is allocated in gdbsim_open()
139 and deallocated in gdbsim_close(). The lifetime needs to extend beyond
140 the call to gdbsim_open() due to the fact that other sim instances other
141 than the first will be allocated after the gdbsim_open() call. */
142static char **sim_argv = NULL;
143
144/* OS-level callback functions for write, flush, etc. */
145static host_callback gdb_callback;
146static int callbacks_initialized = 0;
147
148/* Callback for iterate_over_inferiors. It checks to see if the sim
149 descriptor passed via ARG is the same as that for the inferior
150 designated by INF. Return true if so; false otherwise. */
151
152static int
153check_for_duplicate_sim_descriptor (struct inferior *inf, void *arg)
154{
155 struct sim_inferior_data *sim_data;
653090d3 156 SIM_DESC new_sim_desc = (SIM_DESC) arg;
db04efe6 157
653090d3
SM
158 sim_data = ((struct sim_inferior_data *)
159 inferior_data (inf, sim_inferior_data_key));
db04efe6
KB
160
161 return (sim_data != NULL && sim_data->gdbsim_desc == new_sim_desc);
162}
163
164/* Flags indicating whether or not a sim instance is needed. One of these
165 flags should be passed to get_sim_inferior_data(). */
166
167enum {SIM_INSTANCE_NOT_NEEDED = 0, SIM_INSTANCE_NEEDED = 1};
168
169/* Obtain pointer to per-inferior simulator data, allocating it if necessary.
170 Attempt to open the sim if SIM_INSTANCE_NEEDED is true. */
171
172static struct sim_inferior_data *
173get_sim_inferior_data (struct inferior *inf, int sim_instance_needed)
174{
175 SIM_DESC sim_desc = NULL;
176 struct sim_inferior_data *sim_data
653090d3 177 = (struct sim_inferior_data *) inferior_data (inf, sim_inferior_data_key);
db04efe6
KB
178
179 /* Try to allocate a new sim instance, if needed. We do this ahead of
180 a potential allocation of a sim_inferior_data struct in order to
181 avoid needlessly allocating that struct in the event that the sim
182 instance allocation fails. */
74228e77 183 if (sim_instance_needed == SIM_INSTANCE_NEEDED
db04efe6
KB
184 && (sim_data == NULL || sim_data->gdbsim_desc == NULL))
185 {
186 struct inferior *idup;
187 sim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
188 if (sim_desc == NULL)
189 error (_("Unable to create simulator instance for inferior %d."),
190 inf->num);
191
192 idup = iterate_over_inferiors (check_for_duplicate_sim_descriptor,
74228e77 193 sim_desc);
db04efe6
KB
194 if (idup != NULL)
195 {
196 /* We don't close the descriptor due to the fact that it's
197 shared with some other inferior. If we were to close it,
198 that might needlessly muck up the other inferior. Of
199 course, it's possible that the damage has already been
200 done... Note that it *will* ultimately be closed during
201 cleanup of the other inferior. */
202 sim_desc = NULL;
203 error (
204 _("Inferior %d and inferior %d would have identical simulator state.\n"
205 "(This simulator does not support the running of more than one inferior.)"),
74228e77
RM
206 inf->num, idup->num);
207 }
db04efe6
KB
208 }
209
210 if (sim_data == NULL)
211 {
41bf6aca 212 sim_data = XCNEW(struct sim_inferior_data);
db04efe6
KB
213 set_inferior_data (inf, sim_inferior_data_key, sim_data);
214
215 /* Allocate a ptid for this inferior. */
216 sim_data->remote_sim_ptid = ptid_build (next_pid, 0, next_pid);
217 next_pid++;
218
219 /* Initialize the other instance variables. */
220 sim_data->program_loaded = 0;
221 sim_data->gdbsim_desc = sim_desc;
a493e3e2 222 sim_data->resume_siggnal = GDB_SIGNAL_0;
db04efe6
KB
223 sim_data->resume_step = 0;
224 }
225 else if (sim_desc)
226 {
227 /* This handles the case where sim_data was allocated prior to
74228e77 228 needing a sim instance. */
db04efe6
KB
229 sim_data->gdbsim_desc = sim_desc;
230 }
c906108c 231
c906108c 232
db04efe6
KB
233 return sim_data;
234}
235
236/* Return pointer to per-inferior simulator data using PTID to find the
237 inferior in question. Return NULL when no inferior is found or
238 when ptid has a zero or negative pid component. */
239
240static struct sim_inferior_data *
241get_sim_inferior_data_by_ptid (ptid_t ptid, int sim_instance_needed)
242{
243 struct inferior *inf;
244 int pid = ptid_get_pid (ptid);
245
246 if (pid <= 0)
247 return NULL;
74228e77 248
db04efe6
KB
249 inf = find_inferior_pid (pid);
250
251 if (inf)
252 return get_sim_inferior_data (inf, sim_instance_needed);
253 else
254 return NULL;
255}
256
257/* Free the per-inferior simulator data. */
258
259static void
260sim_inferior_data_cleanup (struct inferior *inf, void *data)
261{
653090d3 262 struct sim_inferior_data *sim_data = (struct sim_inferior_data *) data;
db04efe6
KB
263
264 if (sim_data != NULL)
265 {
266 if (sim_data->gdbsim_desc)
267 {
268 sim_close (sim_data->gdbsim_desc, 0);
269 sim_data->gdbsim_desc = NULL;
270 }
271 xfree (sim_data);
272 }
273}
9de2bdd7 274
c906108c 275static void
146ec4db 276dump_mem (const gdb_byte *buf, int len)
c906108c 277{
1385f66c 278 fputs_unfiltered ("\t", gdb_stdlog);
3d468296
AB
279
280 if (len == 8 || len == 4)
c906108c 281 {
3d468296 282 uint32_t l[2];
123f5f96 283
3d468296 284 memcpy (l, buf, len);
1385f66c 285 fprintf_unfiltered (gdb_stdlog, "0x%08x", l[0]);
3d468296 286 if (len == 8)
1385f66c 287 fprintf_unfiltered (gdb_stdlog, " 0x%08x", l[1]);
3d468296
AB
288 }
289 else
290 {
291 int i;
123f5f96 292
3d468296 293 for (i = 0; i < len; i++)
1385f66c 294 fprintf_unfiltered (gdb_stdlog, "0x%02x ", buf[i]);
c906108c 295 }
3d468296 296
1385f66c 297 fputs_unfiltered ("\n", gdb_stdlog);
c906108c
SS
298}
299
c906108c
SS
300/* Initialize gdb_callback. */
301
302static void
fba45db2 303init_callbacks (void)
c906108c 304{
c5aa993b 305 if (!callbacks_initialized)
c906108c
SS
306 {
307 gdb_callback = default_callback;
308 gdb_callback.init (&gdb_callback);
309 gdb_callback.write_stdout = gdb_os_write_stdout;
310 gdb_callback.flush_stdout = gdb_os_flush_stdout;
311 gdb_callback.write_stderr = gdb_os_write_stderr;
312 gdb_callback.flush_stderr = gdb_os_flush_stderr;
313 gdb_callback.printf_filtered = gdb_os_printf_filtered;
314 gdb_callback.vprintf_filtered = gdb_os_vprintf_filtered;
315 gdb_callback.evprintf_filtered = gdb_os_evprintf_filtered;
316 gdb_callback.error = gdb_os_error;
317 gdb_callback.poll_quit = gdb_os_poll_quit;
318 gdb_callback.magic = HOST_CALLBACK_MAGIC;
319 callbacks_initialized = 1;
320 }
321}
322
323/* Release callbacks (free resources used by them). */
324
325static void
fba45db2 326end_callbacks (void)
c906108c
SS
327{
328 if (callbacks_initialized)
329 {
330 gdb_callback.shutdown (&gdb_callback);
331 callbacks_initialized = 0;
332 }
333}
334
335/* GDB version of os_write_stdout callback. */
336
c5aa993b 337static int
fba45db2 338gdb_os_write_stdout (host_callback *p, const char *buf, int len)
c906108c
SS
339{
340 int i;
341 char b[2];
342
d9fcf2fb 343 ui_file_write (gdb_stdtarg, buf, len);
c906108c
SS
344 return len;
345}
346
347/* GDB version of os_flush_stdout callback. */
348
349static void
fba45db2 350gdb_os_flush_stdout (host_callback *p)
c906108c 351{
4ce44c66 352 gdb_flush (gdb_stdtarg);
c906108c
SS
353}
354
355/* GDB version of os_write_stderr callback. */
356
c5aa993b 357static int
fba45db2 358gdb_os_write_stderr (host_callback *p, const char *buf, int len)
c906108c
SS
359{
360 int i;
361 char b[2];
362
c5aa993b 363 for (i = 0; i < len; i++)
c906108c
SS
364 {
365 b[0] = buf[i];
366 b[1] = 0;
22e8e3c7 367 fputs_unfiltered (b, gdb_stdtargerr);
c906108c
SS
368 }
369 return len;
370}
371
372/* GDB version of os_flush_stderr callback. */
373
374static void
fba45db2 375gdb_os_flush_stderr (host_callback *p)
c906108c 376{
22e8e3c7 377 gdb_flush (gdb_stdtargerr);
c906108c
SS
378}
379
380/* GDB version of printf_filtered callback. */
381
c906108c 382static void
c5aa993b 383gdb_os_printf_filtered (host_callback * p, const char *format,...)
c906108c
SS
384{
385 va_list args;
c906108c 386
123f5f96 387 va_start (args, format);
c906108c 388 vfprintf_filtered (gdb_stdout, format, args);
c906108c
SS
389 va_end (args);
390}
391
392/* GDB version of error vprintf_filtered. */
393
c906108c 394static void
c5aa993b 395gdb_os_vprintf_filtered (host_callback * p, const char *format, va_list ap)
c906108c
SS
396{
397 vfprintf_filtered (gdb_stdout, format, ap);
398}
399
400/* GDB version of error evprintf_filtered. */
401
c906108c 402static void
c5aa993b 403gdb_os_evprintf_filtered (host_callback * p, const char *format, va_list ap)
c906108c
SS
404{
405 vfprintf_filtered (gdb_stderr, format, ap);
406}
407
408/* GDB version of error callback. */
409
c906108c 410static void
58d4abe1 411gdb_os_error (host_callback * p, const char *format, ...)
c906108c 412{
58d4abe1 413 va_list args;
123f5f96 414
58d4abe1
PA
415 va_start (args, format);
416 verror (format, args);
417 va_end (args);
c906108c
SS
418}
419
8238d0bf 420int
e7faf938 421one2one_register_sim_regno (struct gdbarch *gdbarch, int regnum)
8238d0bf
AC
422{
423 /* Only makes sense to supply raw registers. */
e7faf938 424 gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
8238d0bf
AC
425 return regnum;
426}
427
c906108c 428static void
28439f5e
PA
429gdbsim_fetch_register (struct target_ops *ops,
430 struct regcache *regcache, int regno)
c906108c 431{
40a6adc1 432 struct gdbarch *gdbarch = get_regcache_arch (regcache);
bcc0c096 433 struct inferior *inf = find_inferior_ptid (regcache_get_ptid (regcache));
db04efe6 434 struct sim_inferior_data *sim_data
bcc0c096 435 = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
123f5f96 436
c5aa993b 437 if (regno == -1)
c906108c 438 {
40a6adc1 439 for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
28439f5e 440 gdbsim_fetch_register (ops, regcache, regno);
8238d0bf 441 return;
c906108c 442 }
8238d0bf 443
40a6adc1 444 switch (gdbarch_register_sim_regno (gdbarch, regno))
c906108c 445 {
8238d0bf
AC
446 case LEGACY_SIM_REGNO_IGNORE:
447 break;
448 case SIM_REGNO_DOES_NOT_EXIST:
449 {
450 /* For moment treat a `does not exist' register the same way
74228e77 451 as an ``unavailable'' register. */
a4d1e79a 452 regcache->raw_supply_zeroed (regno);
8238d0bf
AC
453 break;
454 }
74228e77 455
8238d0bf
AC
456 default:
457 {
458 static int warn_user = 1;
a4d1e79a
AH
459 int regsize = register_size (gdbarch, regno);
460 gdb::byte_vector buf (regsize, 0);
8238d0bf 461 int nr_bytes;
123f5f96 462
40a6adc1 463 gdb_assert (regno >= 0 && regno < gdbarch_num_regs (gdbarch));
db04efe6 464 nr_bytes = sim_fetch_register (sim_data->gdbsim_desc,
474c1661 465 gdbarch_register_sim_regno
40a6adc1 466 (gdbarch, regno),
a4d1e79a
AH
467 buf.data (), regsize);
468 if (nr_bytes > 0 && nr_bytes != regsize && warn_user)
8238d0bf
AC
469 {
470 fprintf_unfiltered (gdb_stderr,
0df8b418
MS
471 "Size of register %s (%d/%d) "
472 "incorrect (%d instead of %d))",
40a6adc1 473 gdbarch_register_name (gdbarch, regno),
474c1661 474 regno,
a4d1e79a
AH
475 gdbarch_register_sim_regno (gdbarch, regno),
476 nr_bytes, regsize);
8238d0bf
AC
477 warn_user = 0;
478 }
479 /* FIXME: cagney/2002-05-27: Should check `nr_bytes == 0'
278a7cf7 480 indicating that GDB and the SIM have different ideas about
8238d0bf
AC
481 which registers are fetchable. */
482 /* Else if (nr_bytes < 0): an old simulator, that doesn't
483 think to return the register size. Just assume all is ok. */
a4d1e79a 484 regcache->raw_supply (regno, buf.data ());
ea35711c 485 if (remote_debug)
8238d0bf 486 {
1385f66c
PA
487 fprintf_unfiltered (gdb_stdlog,
488 "gdbsim_fetch_register: %d", regno);
8238d0bf 489 /* FIXME: We could print something more intelligible. */
a4d1e79a 490 dump_mem (buf.data (), regsize);
8238d0bf
AC
491 }
492 break;
493 }
c906108c
SS
494 }
495}
496
497
498static void
28439f5e
PA
499gdbsim_store_register (struct target_ops *ops,
500 struct regcache *regcache, int regno)
c906108c 501{
40a6adc1 502 struct gdbarch *gdbarch = get_regcache_arch (regcache);
bcc0c096 503 struct inferior *inf = find_inferior_ptid (regcache_get_ptid (regcache));
db04efe6 504 struct sim_inferior_data *sim_data
bcc0c096 505 = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
db04efe6 506
c5aa993b 507 if (regno == -1)
c906108c 508 {
40a6adc1 509 for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
28439f5e 510 gdbsim_store_register (ops, regcache, regno);
8238d0bf 511 return;
c906108c 512 }
40a6adc1 513 else if (gdbarch_register_sim_regno (gdbarch, regno) >= 0)
c906108c 514 {
a4d1e79a
AH
515 int regsize = register_size (gdbarch, regno);
516 gdb::byte_vector tmp (regsize);
c906108c 517 int nr_bytes;
123f5f96 518
a4d1e79a 519 regcache->cooked_read (regno, tmp.data ());
db04efe6 520 nr_bytes = sim_store_register (sim_data->gdbsim_desc,
474c1661 521 gdbarch_register_sim_regno
40a6adc1 522 (gdbarch, regno),
a4d1e79a
AH
523 tmp.data (), regsize);
524
525 if (nr_bytes > 0 && nr_bytes != regsize)
8e65ff28 526 internal_error (__FILE__, __LINE__,
e2e0b3e5 527 _("Register size different to expected"));
dae477fe 528 if (nr_bytes < 0)
74228e77
RM
529 internal_error (__FILE__, __LINE__,
530 _("Register %d not updated"), regno);
dae477fe 531 if (nr_bytes == 0)
74228e77
RM
532 warning (_("Register %s not updated"),
533 gdbarch_register_name (gdbarch, regno));
dae477fe 534
ea35711c 535 if (remote_debug)
c906108c 536 {
1385f66c 537 fprintf_unfiltered (gdb_stdlog, "gdbsim_store_register: %d", regno);
c906108c 538 /* FIXME: We could print something more intelligible. */
a4d1e79a 539 dump_mem (tmp.data (), regsize);
c906108c
SS
540 }
541 }
542}
543
544/* Kill the running program. This may involve closing any open files
545 and releasing other resources acquired by the simulated program. */
546
547static void
7d85a9c0 548gdbsim_kill (struct target_ops *ops)
c906108c 549{
ea35711c 550 if (remote_debug)
1385f66c 551 fprintf_unfiltered (gdb_stdlog, "gdbsim_kill\n");
c906108c
SS
552
553 /* There is no need to `kill' running simulator - the simulator is
52bb452f 554 not running. Mourning it is enough. */
bc1e6c81 555 target_mourn_inferior (inferior_ptid);
c906108c
SS
556}
557
558/* Load an executable file into the target process. This is expected to
559 not only bring new code into the target process, but also to update
560 GDB's symbol tables to match. */
561
562static void
9cbe5fff 563gdbsim_load (struct target_ops *self, const char *args, int fromtty)
c906108c 564{
b2b255bd 565 const char *prog;
db04efe6
KB
566 struct sim_inferior_data *sim_data
567 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
1986bccd 568
d1a41061
PP
569 if (args == NULL)
570 error_no_arg (_("program to load"));
1986bccd 571
773a1edc 572 gdb_argv argv (args);
1986bccd
AS
573
574 prog = tilde_expand (argv[0]);
575
576 if (argv[1] != NULL)
577 error (_("GDB sim does not yet support a load offset."));
578
ea35711c 579 if (remote_debug)
1385f66c 580 fprintf_unfiltered (gdb_stdlog, "gdbsim_load: prog \"%s\"\n", prog);
c906108c 581
c906108c
SS
582 /* FIXME: We will print two messages on error.
583 Need error to either not print anything if passed NULL or need
584 another routine that doesn't take any arguments. */
db04efe6 585 if (sim_load (sim_data->gdbsim_desc, prog, NULL, fromtty) == SIM_RC_FAIL)
8a3fe4f8 586 error (_("unable to load program"));
c906108c
SS
587
588 /* FIXME: If a load command should reset the targets registers then
0df8b418 589 a call to sim_create_inferior() should go here. */
c906108c 590
db04efe6 591 sim_data->program_loaded = 1;
c906108c
SS
592}
593
594
39f77062 595/* Start an inferior process and set inferior_ptid to its pid.
c906108c
SS
596 EXEC_FILE is the file to run.
597 ARGS is a string containing the arguments to the program.
598 ENV is the environment vector to pass. Errors reported with error().
599 On VxWorks and various standalone systems, we ignore exec_file. */
600/* This is called not only when we first attach, but also when the
601 user types "run" after having attached. */
602
603static void
7c5ded6a
SDJ
604gdbsim_create_inferior (struct target_ops *target, const char *exec_file,
605 const std::string &allargs, char **env, int from_tty)
c906108c 606{
db04efe6
KB
607 struct sim_inferior_data *sim_data
608 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
c906108c 609 int len;
773a1edc 610 char *arg_buf;
7c5ded6a 611 const char *args = allargs.c_str ();
c906108c
SS
612
613 if (exec_file == 0 || exec_bfd == 0)
8a3fe4f8 614 warning (_("No executable file specified."));
db04efe6 615 if (!sim_data->program_loaded)
8a3fe4f8 616 warning (_("No program loaded."));
c906108c 617
ea35711c 618 if (remote_debug)
1385f66c
PA
619 fprintf_unfiltered (gdb_stdlog,
620 "gdbsim_create_inferior: exec_file \"%s\", args \"%s\"\n",
621 (exec_file ? exec_file : "(NULL)"),
622 args);
c906108c 623
db04efe6 624 if (ptid_equal (inferior_ptid, sim_data->remote_sim_ptid))
7d85a9c0 625 gdbsim_kill (target);
c906108c
SS
626 remove_breakpoints ();
627 init_wait_for_inferior ();
628
773a1edc 629 gdb_argv built_argv;
c906108c
SS
630 if (exec_file != NULL)
631 {
7c5ded6a 632 len = strlen (exec_file) + 1 + allargs.size () + 1 + /*slop */ 10;
c906108c
SS
633 arg_buf = (char *) alloca (len);
634 arg_buf[0] = '\0';
635 strcat (arg_buf, exec_file);
636 strcat (arg_buf, " ");
637 strcat (arg_buf, args);
773a1edc 638 built_argv.reset (arg_buf);
c906108c 639 }
ddd60447 640
2a7c8fd5
AB
641 if (!have_inferiors ())
642 init_thread_list ();
643
773a1edc
TT
644 if (sim_create_inferior (sim_data->gdbsim_desc, exec_bfd,
645 built_argv.get (), env)
ddd60447
MF
646 != SIM_RC_OK)
647 error (_("Unable to create sim inferior."));
c906108c 648
db04efe6 649 inferior_ptid = sim_data->remote_sim_ptid;
20176d8f 650 inferior_appeared (current_inferior (), ptid_get_pid (inferior_ptid));
9de2bdd7
PA
651 add_thread_silent (inferior_ptid);
652
0df8b418
MS
653 insert_breakpoints (); /* Needed to get correct instruction
654 in cache. */
c906108c 655
88056fbb 656 clear_proceed_status (0);
c906108c
SS
657}
658
659/* The open routine takes the rest of the parameters from the command,
660 and (if successful) pushes a new target onto the stack.
661 Targets should supply this routine, if only to provide an error message. */
0df8b418 662/* Called when selecting the simulator. E.g. (gdb) target sim name. */
c906108c
SS
663
664static void
014f9477 665gdbsim_open (const char *args, int from_tty)
c906108c
SS
666{
667 int len;
668 char *arg_buf;
db04efe6 669 struct sim_inferior_data *sim_data;
87d1b309 670 const char *sysroot;
db04efe6 671 SIM_DESC gdbsim_desc;
c906108c 672
87d1b309
MF
673 sysroot = gdb_sysroot;
674 if (is_target_filename (sysroot))
675 sysroot += strlen (TARGET_SYSROOT_PREFIX);
676
ea35711c 677 if (remote_debug)
1385f66c
PA
678 fprintf_unfiltered (gdb_stdlog,
679 "gdbsim_open: args \"%s\"\n", args ? args : "(null)");
c906108c 680
db04efe6
KB
681 /* Ensure that the sim target is not on the target stack. This is
682 necessary, because if it is on the target stack, the call to
683 push_target below will invoke sim_close(), thus freeing various
684 state (including a sim instance) that we allocate prior to
685 invoking push_target(). We want to delay the push_target()
686 operation until after we complete those operations which could
687 error out. */
688 if (gdbsim_is_open)
c906108c
SS
689 unpush_target (&gdbsim_ops);
690
c5aa993b 691 len = (7 + 1 /* gdbsim */
c906108c
SS
692 + strlen (" -E little")
693 + strlen (" --architecture=xxxxxxxxxx")
23bf70af 694 + strlen (" --sysroot=") + strlen (sysroot) +
c906108c 695 + (args ? strlen (args) : 0)
c5aa993b 696 + 50) /* slack */ ;
c906108c 697 arg_buf = (char *) alloca (len);
c5aa993b 698 strcpy (arg_buf, "gdbsim"); /* 7 */
b6d373df 699 /* Specify the byte order for the target when it is explicitly
0df8b418 700 specified by the user (not auto detected). */
b6d373df 701 switch (selected_byte_order ())
c906108c 702 {
a8cf2722
AC
703 case BFD_ENDIAN_BIG:
704 strcat (arg_buf, " -E big");
705 break;
706 case BFD_ENDIAN_LITTLE:
707 strcat (arg_buf, " -E little");
708 break;
709 case BFD_ENDIAN_UNKNOWN:
710 break;
c906108c
SS
711 }
712 /* Specify the architecture of the target when it has been
713 explicitly specified */
a8cf2722 714 if (selected_architecture_name () != NULL)
c906108c
SS
715 {
716 strcat (arg_buf, " --architecture=");
a8cf2722 717 strcat (arg_buf, selected_architecture_name ());
c906108c 718 }
f4b8c29b
MF
719 /* Pass along gdb's concept of the sysroot. */
720 strcat (arg_buf, " --sysroot=");
23bf70af 721 strcat (arg_buf, sysroot);
c906108c
SS
722 /* finally, any explicit args */
723 if (args)
724 {
c5aa993b 725 strcat (arg_buf, " "); /* 1 */
c906108c
SS
726 strcat (arg_buf, args);
727 }
773a1edc 728
74cbb09e
SM
729 gdb_argv argv (arg_buf);
730 sim_argv = argv.get ();
c906108c
SS
731
732 init_callbacks ();
db04efe6 733 gdbsim_desc = sim_open (SIM_OPEN_DEBUG, &gdb_callback, exec_bfd, sim_argv);
c906108c
SS
734
735 if (gdbsim_desc == 0)
db04efe6 736 {
db04efe6
KB
737 sim_argv = NULL;
738 error (_("unable to create simulator instance"));
739 }
740
74cbb09e 741 argv.release ();
773a1edc 742
db04efe6
KB
743 /* Reset the pid numberings for this batch of sim instances. */
744 next_pid = INITIAL_PID;
745
746 /* Allocate the inferior data, but do not allocate a sim instance
747 since we've already just done that. */
0df8b418
MS
748 sim_data = get_sim_inferior_data (current_inferior (),
749 SIM_INSTANCE_NOT_NEEDED);
db04efe6
KB
750
751 sim_data->gdbsim_desc = gdbsim_desc;
c906108c
SS
752
753 push_target (&gdbsim_ops);
c906108c 754 printf_filtered ("Connected to the simulator.\n");
52bb452f
DJ
755
756 /* There's nothing running after "target sim" or "load"; not until
757 "run". */
758 inferior_ptid = null_ptid;
db04efe6
KB
759
760 gdbsim_is_open = 1;
761}
762
763/* Callback for iterate_over_inferiors. Called (indirectly) by
764 gdbsim_close(). */
765
766static int
767gdbsim_close_inferior (struct inferior *inf, void *arg)
768{
653090d3
SM
769 struct sim_inferior_data *sim_data
770 = (struct sim_inferior_data *) inferior_data (inf, sim_inferior_data_key);
db04efe6
KB
771 if (sim_data != NULL)
772 {
773 ptid_t ptid = sim_data->remote_sim_ptid;
774
775 sim_inferior_data_cleanup (inf, sim_data);
776 set_inferior_data (inf, sim_inferior_data_key, NULL);
777
778 /* Having a ptid allocated and stored in remote_sim_ptid does
0df8b418 779 not mean that a corresponding inferior was ever created.
db04efe6
KB
780 Thus we need to verify the existence of an inferior using the
781 pid in question before setting inferior_ptid via
782 switch_to_thread() or mourning the inferior. */
c9657e70 783 if (find_inferior_ptid (ptid) != NULL)
db04efe6
KB
784 {
785 switch_to_thread (ptid);
786 generic_mourn_inferior ();
787 }
788 }
789
790 return 0;
c906108c
SS
791}
792
0df8b418 793/* Close out all files and local state before this target loses control. */
c906108c
SS
794
795static void
de90e03d 796gdbsim_close (struct target_ops *self)
c906108c 797{
db04efe6
KB
798 struct sim_inferior_data *sim_data
799 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
800
ea35711c 801 if (remote_debug)
1385f66c 802 fprintf_unfiltered (gdb_stdlog, "gdbsim_close\n");
c906108c 803
db04efe6 804 iterate_over_inferiors (gdbsim_close_inferior, NULL);
c906108c 805
db04efe6 806 if (sim_argv != NULL)
c906108c 807 {
db04efe6
KB
808 freeargv (sim_argv);
809 sim_argv = NULL;
c906108c
SS
810 }
811
812 end_callbacks ();
db04efe6
KB
813
814 gdbsim_is_open = 0;
c906108c
SS
815}
816
817/* Takes a program previously attached to and detaches it.
818 The program may resume execution (some targets do, some don't) and will
819 no longer stop on signals, etc. We better not have left any breakpoints
820 in the program or it'll die when it hits one. ARGS is arguments
821 typed by the user (e.g. a signal to send the process). FROM_TTY
822 says whether to be verbose or not. */
823/* Terminate the open connection to the remote debugger.
824 Use this when you want to detach and do something else with your gdb. */
825
826static void
52554a0e 827gdbsim_detach (struct target_ops *ops, const char *args, int from_tty)
c906108c 828{
ea35711c 829 if (remote_debug)
1385f66c 830 fprintf_unfiltered (gdb_stdlog, "gdbsim_detach: args \"%s\"\n", args);
c906108c 831
7fdc1521 832 unpush_target (ops); /* calls gdbsim_close to do the real work */
c906108c
SS
833 if (from_tty)
834 printf_filtered ("Ending simulator %s debugging\n", target_shortname);
835}
c5aa993b 836
c906108c
SS
837/* Resume execution of the target process. STEP says whether to single-step
838 or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
839 to the target, or zero for no signal. */
840
db04efe6
KB
841struct resume_data
842{
2ea28649 843 enum gdb_signal siggnal;
db04efe6
KB
844 int step;
845};
846
847static int
848gdbsim_resume_inferior (struct inferior *inf, void *arg)
849{
850 struct sim_inferior_data *sim_data
851 = get_sim_inferior_data (inf, SIM_INSTANCE_NOT_NEEDED);
653090d3 852 struct resume_data *rd = (struct resume_data *) arg;
db04efe6
KB
853
854 if (sim_data)
855 {
856 sim_data->resume_siggnal = rd->siggnal;
857 sim_data->resume_step = rd->step;
858
859 if (remote_debug)
1385f66c
PA
860 fprintf_unfiltered (gdb_stdlog,
861 _("gdbsim_resume: pid %d, step %d, signal %d\n"),
862 inf->pid, rd->step, rd->siggnal);
db04efe6
KB
863 }
864
865 /* When called from iterate_over_inferiors, a zero return causes the
866 iteration process to proceed until there are no more inferiors to
867 consider. */
868 return 0;
869}
c906108c
SS
870
871static void
2fb89e62 872gdbsim_resume (struct target_ops *ops,
2ea28649 873 ptid_t ptid, int step, enum gdb_signal siggnal)
c906108c 874{
db04efe6
KB
875 struct resume_data rd;
876 struct sim_inferior_data *sim_data
877 = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
878
879 rd.siggnal = siggnal;
880 rd.step = step;
881
0df8b418 882 /* We don't access any sim_data members within this function.
db04efe6
KB
883 What's of interest is whether or not the call to
884 get_sim_inferior_data_by_ptid(), above, is able to obtain a
885 non-NULL pointer. If it managed to obtain a non-NULL pointer, we
886 know we have a single inferior to consider. If it's NULL, we
887 either have multiple inferiors to resume or an error condition. */
888
889 if (sim_data)
c9657e70 890 gdbsim_resume_inferior (find_inferior_ptid (ptid), &rd);
db04efe6
KB
891 else if (ptid_equal (ptid, minus_one_ptid))
892 iterate_over_inferiors (gdbsim_resume_inferior, &rd);
893 else
8a3fe4f8 894 error (_("The program is not being run."));
c906108c
SS
895}
896
bfedc46a 897/* Notify the simulator of an asynchronous request to interrupt.
c5aa993b 898
bfedc46a 899 The simulator shall ensure that the interrupt request is eventually
c906108c 900 delivered to the simulator. If the call is made while the
bfedc46a 901 simulator is not running then the interrupt request is processed when
c906108c
SS
902 the simulator is next resumed.
903
db04efe6
KB
904 For simulators that do not support this operation, just abort. */
905
906static int
bfedc46a 907gdbsim_interrupt_inferior (struct inferior *inf, void *arg)
db04efe6
KB
908{
909 struct sim_inferior_data *sim_data
910 = get_sim_inferior_data (inf, SIM_INSTANCE_NEEDED);
911
912 if (sim_data)
913 {
914 if (!sim_stop (sim_data->gdbsim_desc))
915 {
916 quit ();
917 }
918 }
919
920 /* When called from iterate_over_inferiors, a zero return causes the
921 iteration process to proceed until there are no more inferiors to
922 consider. */
923 return 0;
924}
c906108c
SS
925
926static void
bfedc46a 927gdbsim_interrupt (struct target_ops *self, ptid_t ptid)
c906108c 928{
db04efe6
KB
929 struct sim_inferior_data *sim_data;
930
931 if (ptid_equal (ptid, minus_one_ptid))
c906108c 932 {
bfedc46a 933 iterate_over_inferiors (gdbsim_interrupt_inferior, NULL);
db04efe6
KB
934 }
935 else
936 {
c9657e70 937 struct inferior *inf = find_inferior_ptid (ptid);
db04efe6
KB
938
939 if (inf == NULL)
0df8b418
MS
940 error (_("Can't stop pid %d. No inferior found."),
941 ptid_get_pid (ptid));
db04efe6 942
bfedc46a 943 gdbsim_interrupt_inferior (inf, NULL);
c906108c
SS
944 }
945}
946
947/* GDB version of os_poll_quit callback.
8a0ce09a 948 Taken from gdb/util.c - should be in a library. */
c906108c
SS
949
950static int
fba45db2 951gdb_os_poll_quit (host_callback *p)
c906108c 952{
98bbd631
AC
953 if (deprecated_ui_loop_hook != NULL)
954 deprecated_ui_loop_hook (0);
7a292a7a 955
522002f9 956 if (check_quit_flag ()) /* gdb's idea of quit */
abf009ef 957 return 1;
c906108c
SS
958 return 0;
959}
960
961/* Wait for inferior process to do something. Return pid of child,
962 or -1 in case of error; store status through argument pointer STATUS,
0df8b418 963 just as `wait' would. */
c906108c
SS
964
965static void
fba45db2 966gdbsim_cntrl_c (int signo)
c906108c 967{
bfedc46a 968 gdbsim_interrupt (NULL, minus_one_ptid);
c906108c
SS
969}
970
39f77062 971static ptid_t
117de6a9 972gdbsim_wait (struct target_ops *ops,
47608cb1 973 ptid_t ptid, struct target_waitstatus *status, int options)
c906108c 974{
db04efe6 975 struct sim_inferior_data *sim_data;
a40805d4 976 static sighandler_t prev_sigint;
c906108c
SS
977 int sigrc = 0;
978 enum sim_stop reason = sim_running;
979
db04efe6
KB
980 /* This target isn't able to (yet) resume more than one inferior at a time.
981 When ptid is minus_one_ptid, just use the current inferior. If we're
982 given an explicit pid, we'll try to find it and use that instead. */
983 if (ptid_equal (ptid, minus_one_ptid))
0df8b418
MS
984 sim_data = get_sim_inferior_data (current_inferior (),
985 SIM_INSTANCE_NEEDED);
db04efe6
KB
986 else
987 {
988 sim_data = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NEEDED);
989 if (sim_data == NULL)
990 error (_("Unable to wait for pid %d. Inferior not found."),
991 ptid_get_pid (ptid));
992 inferior_ptid = ptid;
993 }
994
ea35711c 995 if (remote_debug)
1385f66c 996 fprintf_unfiltered (gdb_stdlog, "gdbsim_wait\n");
c906108c
SS
997
998#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
999 {
1000 struct sigaction sa, osa;
1001 sa.sa_handler = gdbsim_cntrl_c;
1002 sigemptyset (&sa.sa_mask);
1003 sa.sa_flags = 0;
1004 sigaction (SIGINT, &sa, &osa);
1005 prev_sigint = osa.sa_handler;
1006 }
1007#else
1008 prev_sigint = signal (SIGINT, gdbsim_cntrl_c);
1009#endif
db04efe6 1010 sim_resume (sim_data->gdbsim_desc, sim_data->resume_step,
74228e77 1011 sim_data->resume_siggnal);
db04efe6 1012
c906108c 1013 signal (SIGINT, prev_sigint);
db04efe6 1014 sim_data->resume_step = 0;
c906108c 1015
db04efe6 1016 sim_stop_reason (sim_data->gdbsim_desc, &reason, &sigrc);
c906108c
SS
1017
1018 switch (reason)
1019 {
1020 case sim_exited:
1021 status->kind = TARGET_WAITKIND_EXITED;
1022 status->value.integer = sigrc;
1023 break;
1024 case sim_stopped:
1025 switch (sigrc)
1026 {
a493e3e2 1027 case GDB_SIGNAL_ABRT:
c906108c
SS
1028 quit ();
1029 break;
a493e3e2
PA
1030 case GDB_SIGNAL_INT:
1031 case GDB_SIGNAL_TRAP:
c906108c
SS
1032 default:
1033 status->kind = TARGET_WAITKIND_STOPPED;
653090d3 1034 status->value.sig = (enum gdb_signal) sigrc;
c906108c
SS
1035 break;
1036 }
1037 break;
1038 case sim_signalled:
1039 status->kind = TARGET_WAITKIND_SIGNALLED;
653090d3 1040 status->value.sig = (enum gdb_signal) sigrc;
c906108c
SS
1041 break;
1042 case sim_running:
1043 case sim_polling:
0df8b418 1044 /* FIXME: Is this correct? */
c906108c
SS
1045 break;
1046 }
1047
39f77062 1048 return inferior_ptid;
c906108c
SS
1049}
1050
1051/* Get ready to modify the registers array. On machines which store
1052 individual registers, this doesn't need to do anything. On machines
1053 which store all the registers in one fell swoop, this makes sure
1054 that registers contains all the registers from the program being
1055 debugged. */
1056
1057static void
f32dbf8c 1058gdbsim_prepare_to_store (struct target_ops *self, struct regcache *regcache)
c906108c 1059{
0df8b418 1060 /* Do nothing, since we can store individual regs. */
c906108c
SS
1061}
1062
146ec4db
PA
1063/* Helper for gdbsim_xfer_partial that handles memory transfers.
1064 Arguments are like target_xfer_partial. */
d93bce06 1065
9b409511 1066static enum target_xfer_status
146ec4db
PA
1067gdbsim_xfer_memory (struct target_ops *target,
1068 gdb_byte *readbuf, const gdb_byte *writebuf,
9b409511 1069 ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
c906108c 1070{
db04efe6
KB
1071 struct sim_inferior_data *sim_data
1072 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
b55e14c7 1073 int l;
db04efe6 1074
0c012db1
KB
1075 /* If this target doesn't have memory yet, return 0 causing the
1076 request to be passed to a lower target, hopefully an exec
1077 file. */
1078 if (!target->to_has_memory (target))
9b409511 1079 return TARGET_XFER_EOF;
52bb452f 1080
db04efe6 1081 if (!sim_data->program_loaded)
8a3fe4f8 1082 error (_("No program loaded."));
c906108c 1083
db04efe6
KB
1084 /* Note that we obtained the sim_data pointer above using
1085 SIM_INSTANCE_NOT_NEEDED. We do this so that we don't needlessly
1086 allocate a sim instance prior to loading a program. If we
1087 get to this point in the code though, gdbsim_desc should be
1088 non-NULL. (Note that a sim instance is needed in order to load
1089 the program...) */
1090 gdb_assert (sim_data->gdbsim_desc != NULL);
1091
ea35711c 1092 if (remote_debug)
fcde0081 1093 fprintf_unfiltered (gdb_stdlog,
146ec4db
PA
1094 "gdbsim_xfer_memory: readbuf %s, writebuf %s, "
1095 "memaddr %s, len %s\n",
1096 host_address_to_string (readbuf),
1097 host_address_to_string (writebuf),
fcde0081 1098 paddress (target_gdbarch (), memaddr),
b55e14c7 1099 pulongest (len));
c906108c 1100
146ec4db 1101 if (writebuf)
c906108c 1102 {
fcde0081 1103 if (remote_debug && len > 0)
146ec4db 1104 dump_mem (writebuf, len);
b55e14c7 1105 l = sim_write (sim_data->gdbsim_desc, memaddr, writebuf, len);
c906108c 1106 }
c5aa993b 1107 else
c906108c 1108 {
b55e14c7 1109 l = sim_read (sim_data->gdbsim_desc, memaddr, readbuf, len);
ea35711c 1110 if (remote_debug && len > 0)
146ec4db 1111 dump_mem (readbuf, len);
c5aa993b 1112 }
9b409511
YQ
1113 if (l > 0)
1114 {
1115 *xfered_len = (ULONGEST) l;
1116 return TARGET_XFER_OK;
1117 }
1118 else if (l == 0)
1119 return TARGET_XFER_EOF;
1120 else
1121 return TARGET_XFER_E_IO;
c906108c
SS
1122}
1123
146ec4db
PA
1124/* Target to_xfer_partial implementation. */
1125
9b409511 1126static enum target_xfer_status
146ec4db
PA
1127gdbsim_xfer_partial (struct target_ops *ops, enum target_object object,
1128 const char *annex, gdb_byte *readbuf,
9b409511
YQ
1129 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
1130 ULONGEST *xfered_len)
146ec4db
PA
1131{
1132 switch (object)
1133 {
1134 case TARGET_OBJECT_MEMORY:
9b409511
YQ
1135 return gdbsim_xfer_memory (ops, readbuf, writebuf, offset, len,
1136 xfered_len);
146ec4db
PA
1137
1138 default:
2ed4b548 1139 return TARGET_XFER_E_IO;
146ec4db
PA
1140 }
1141}
1142
c906108c 1143static void
fba45db2 1144gdbsim_files_info (struct target_ops *target)
c906108c 1145{
db04efe6
KB
1146 struct sim_inferior_data *sim_data
1147 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NEEDED);
0d18d720 1148 const char *file = "nothing";
c906108c
SS
1149
1150 if (exec_bfd)
1151 file = bfd_get_filename (exec_bfd);
1152
ea35711c 1153 if (remote_debug)
1385f66c 1154 fprintf_unfiltered (gdb_stdlog, "gdbsim_files_info: file \"%s\"\n", file);
c906108c
SS
1155
1156 if (exec_bfd)
1157 {
1385f66c
PA
1158 fprintf_unfiltered (gdb_stdlog, "\tAttached to %s running program %s\n",
1159 target_shortname, file);
db04efe6 1160 sim_info (sim_data->gdbsim_desc, 0);
c906108c
SS
1161 }
1162}
1163
1164/* Clear the simulator's notion of what the break points are. */
1165
1166static void
3c8b2eda 1167gdbsim_mourn_inferior (struct target_ops *target)
c5aa993b 1168{
db04efe6
KB
1169 struct sim_inferior_data *sim_data
1170 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1171
ea35711c 1172 if (remote_debug)
1385f66c 1173 fprintf_unfiltered (gdb_stdlog, "gdbsim_mourn_inferior:\n");
c906108c
SS
1174
1175 remove_breakpoints ();
1176 generic_mourn_inferior ();
db04efe6 1177 delete_thread_silent (sim_data->remote_sim_ptid);
c906108c
SS
1178}
1179
c906108c
SS
1180/* Pass the command argument through to the simulator verbatim. The
1181 simulator must do any command interpretation work. */
1182
1183void
fba45db2 1184simulator_command (char *args, int from_tty)
c906108c 1185{
db04efe6
KB
1186 struct sim_inferior_data *sim_data;
1187
1188 /* We use inferior_data() instead of get_sim_inferior_data() here in
1189 order to avoid attaching a sim_inferior_data struct to an
1190 inferior unnecessarily. The reason we take such care here is due
1191 to the fact that this function, simulator_command(), may be called
1192 even when the sim target is not active. If we were to use
1193 get_sim_inferior_data() here, it is possible that this call would
1194 be made either prior to gdbsim_open() or after gdbsim_close(),
1195 thus allocating memory that would not be garbage collected until
1196 the ultimate destruction of the associated inferior. */
1197
653090d3
SM
1198 sim_data = ((struct sim_inferior_data *)
1199 inferior_data (current_inferior (), sim_inferior_data_key));
db04efe6 1200 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
c906108c
SS
1201 {
1202
1203 /* PREVIOUSLY: The user may give a command before the simulator
74228e77
RM
1204 is opened. [...] (??? assuming of course one wishes to
1205 continue to allow commands to be sent to unopened simulators,
1206 which isn't entirely unreasonable). */
c906108c
SS
1207
1208 /* The simulator is a builtin abstraction of a remote target.
74228e77
RM
1209 Consistent with that model, access to the simulator, via sim
1210 commands, is restricted to the period when the channel to the
1211 simulator is open. */
c906108c 1212
8a3fe4f8 1213 error (_("Not connected to the simulator target"));
c906108c
SS
1214 }
1215
db04efe6 1216 sim_do_command (sim_data->gdbsim_desc, args);
c906108c
SS
1217
1218 /* Invalidate the register cache, in case the simulator command does
0df8b418 1219 something funny. */
c5aa993b 1220 registers_changed ();
c906108c
SS
1221}
1222
386535dd
PA
1223static void
1224sim_command_completer (struct cmd_list_element *ignore,
1225 completion_tracker &tracker,
1226 const char *text, const char *word)
56a9aa1d
MF
1227{
1228 struct sim_inferior_data *sim_data;
1229
653090d3
SM
1230 sim_data = ((struct sim_inferior_data *)
1231 inferior_data (current_inferior (), sim_inferior_data_key));
56a9aa1d 1232 if (sim_data == NULL || sim_data->gdbsim_desc == NULL)
386535dd 1233 return;
56a9aa1d 1234
386535dd
PA
1235 /* sim_complete_command returns a NULL-terminated malloc'ed array of
1236 malloc'ed strings. */
1237 struct sim_completions_deleter
1238 {
1239 void operator() (char **ptr) const
1240 {
1241 for (size_t i = 0; ptr[i] != NULL; i++)
1242 xfree (ptr[i]);
1243 xfree (ptr);
1244 }
1245 };
1246
1247 std::unique_ptr<char *[], sim_completions_deleter> sim_completions
1248 (sim_complete_command (sim_data->gdbsim_desc, text, word));
1249 if (sim_completions == NULL)
1250 return;
34370865 1251
386535dd
PA
1252 /* Count the elements and add completions from tail to head because
1253 below we'll swap elements out of the array in case add_completion
1254 throws and the deleter deletes until it finds a NULL element. */
1255 size_t count = 0;
1256 while (sim_completions[count] != NULL)
1257 count++;
34370865 1258
386535dd
PA
1259 for (size_t i = count; i > 0; i--)
1260 {
1261 gdb::unique_xmalloc_ptr<char> match (sim_completions[i - 1]);
1262 sim_completions[i - 1] = NULL;
1263 tracker.add_completion (std::move (match));
1264 }
56a9aa1d
MF
1265}
1266
9de2bdd7
PA
1267/* Check to see if a thread is still alive. */
1268
1269static int
28439f5e 1270gdbsim_thread_alive (struct target_ops *ops, ptid_t ptid)
9de2bdd7 1271{
db04efe6
KB
1272 struct sim_inferior_data *sim_data
1273 = get_sim_inferior_data_by_ptid (ptid, SIM_INSTANCE_NOT_NEEDED);
1274
1275 if (sim_data == NULL)
1276 return 0;
1277
1278 if (ptid_equal (ptid, sim_data->remote_sim_ptid))
9de2bdd7
PA
1279 /* The simulators' task is always alive. */
1280 return 1;
1281
1282 return 0;
1283}
1284
1285/* Convert a thread ID to a string. Returns the string in a static
1286 buffer. */
1287
7a114964 1288static const char *
117de6a9 1289gdbsim_pid_to_str (struct target_ops *ops, ptid_t ptid)
9de2bdd7 1290{
9de2bdd7
PA
1291 return normal_pid_to_str (ptid);
1292}
1293
0c012db1
KB
1294/* Simulator memory may be accessed after the program has been loaded. */
1295
b261e0c5 1296static int
0c012db1
KB
1297gdbsim_has_all_memory (struct target_ops *ops)
1298{
1299 struct sim_inferior_data *sim_data
1300 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1301
1302 if (!sim_data->program_loaded)
1303 return 0;
1304
1305 return 1;
1306}
1307
b261e0c5 1308static int
0c012db1
KB
1309gdbsim_has_memory (struct target_ops *ops)
1310{
1311 struct sim_inferior_data *sim_data
1312 = get_sim_inferior_data (current_inferior (), SIM_INSTANCE_NOT_NEEDED);
1313
1314 if (!sim_data->program_loaded)
1315 return 0;
1316
1317 return 1;
1318}
1319
0df8b418 1320/* Define the target subroutine names. */
c906108c 1321
c5aa993b
JM
1322struct target_ops gdbsim_ops;
1323
1324static void
1325init_gdbsim_ops (void)
1326{
1327 gdbsim_ops.to_shortname = "sim";
1328 gdbsim_ops.to_longname = "simulator";
1329 gdbsim_ops.to_doc = "Use the compiled-in simulator.";
1330 gdbsim_ops.to_open = gdbsim_open;
1331 gdbsim_ops.to_close = gdbsim_close;
c5aa993b 1332 gdbsim_ops.to_detach = gdbsim_detach;
c5aa993b
JM
1333 gdbsim_ops.to_resume = gdbsim_resume;
1334 gdbsim_ops.to_wait = gdbsim_wait;
c5aa993b
JM
1335 gdbsim_ops.to_fetch_registers = gdbsim_fetch_register;
1336 gdbsim_ops.to_store_registers = gdbsim_store_register;
1337 gdbsim_ops.to_prepare_to_store = gdbsim_prepare_to_store;
146ec4db 1338 gdbsim_ops.to_xfer_partial = gdbsim_xfer_partial;
c5aa993b 1339 gdbsim_ops.to_files_info = gdbsim_files_info;
8181d85f
DJ
1340 gdbsim_ops.to_insert_breakpoint = memory_insert_breakpoint;
1341 gdbsim_ops.to_remove_breakpoint = memory_remove_breakpoint;
c5aa993b
JM
1342 gdbsim_ops.to_kill = gdbsim_kill;
1343 gdbsim_ops.to_load = gdbsim_load;
c5aa993b 1344 gdbsim_ops.to_create_inferior = gdbsim_create_inferior;
c5aa993b 1345 gdbsim_ops.to_mourn_inferior = gdbsim_mourn_inferior;
bfedc46a 1346 gdbsim_ops.to_interrupt = gdbsim_interrupt;
9de2bdd7
PA
1347 gdbsim_ops.to_thread_alive = gdbsim_thread_alive;
1348 gdbsim_ops.to_pid_to_str = gdbsim_pid_to_str;
c5aa993b 1349 gdbsim_ops.to_stratum = process_stratum;
0c012db1
KB
1350 gdbsim_ops.to_has_all_memory = gdbsim_has_all_memory;
1351 gdbsim_ops.to_has_memory = gdbsim_has_memory;
c35b1492
PA
1352 gdbsim_ops.to_has_stack = default_child_has_stack;
1353 gdbsim_ops.to_has_registers = default_child_has_registers;
1354 gdbsim_ops.to_has_execution = default_child_has_execution;
c5aa993b 1355 gdbsim_ops.to_magic = OPS_MAGIC;
c906108c
SS
1356}
1357
1358void
fba45db2 1359_initialize_remote_sim (void)
c906108c 1360{
56a9aa1d
MF
1361 struct cmd_list_element *c;
1362
c5aa993b 1363 init_gdbsim_ops ();
c906108c
SS
1364 add_target (&gdbsim_ops);
1365
56a9aa1d
MF
1366 c = add_com ("sim", class_obscure, simulator_command,
1367 _("Send a command to the simulator."));
1368 set_cmd_completer (c, sim_command_completer);
9de2bdd7 1369
db04efe6 1370 sim_inferior_data_key
c5d9b215 1371 = register_inferior_data_with_cleanup (NULL, sim_inferior_data_cleanup);
c906108c 1372}
This page took 1.805684 seconds and 4 git commands to generate.