daily update
[deliverable/binutils-gdb.git] / gdb / target.c
1 /* Select target systems and architectures at runtime for GDB.
2
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5
6 Contributed by Cygnus Support.
7
8 This file is part of GDB.
9
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
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
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.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
24
25 #include "defs.h"
26 #include <errno.h>
27 #include "gdb_string.h"
28 #include "target.h"
29 #include "gdbcmd.h"
30 #include "symtab.h"
31 #include "inferior.h"
32 #include "bfd.h"
33 #include "symfile.h"
34 #include "objfiles.h"
35 #include "gdb_wait.h"
36 #include "dcache.h"
37 #include <signal.h>
38 #include "regcache.h"
39 #include "gdb_assert.h"
40 #include "gdbcore.h"
41
42 static void target_info (char *, int);
43
44 static void maybe_kill_then_attach (char *, int);
45
46 static void kill_or_be_killed (int);
47
48 static void default_terminal_info (char *, int);
49
50 static int default_region_size_ok_for_hw_watchpoint (int);
51
52 static int nosymbol (char *, CORE_ADDR *);
53
54 static void tcomplain (void);
55
56 static int nomemory (CORE_ADDR, char *, int, int, struct target_ops *);
57
58 static int return_zero (void);
59
60 static int return_one (void);
61
62 static int return_minus_one (void);
63
64 void target_ignore (void);
65
66 static void target_command (char *, int);
67
68 static struct target_ops *find_default_run_target (char *);
69
70 static void nosupport_runtime (void);
71
72 static LONGEST default_xfer_partial (struct target_ops *ops,
73 enum target_object object,
74 const char *annex, void *readbuf,
75 const void *writebuf,
76 ULONGEST offset, LONGEST len);
77
78 /* Transfer LEN bytes between target address MEMADDR and GDB address
79 MYADDR. Returns 0 for success, errno code for failure (which
80 includes partial transfers -- if you want a more useful response to
81 partial transfers, try either target_read_memory_partial or
82 target_write_memory_partial). */
83
84 static int target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len,
85 int write);
86
87 static void init_dummy_target (void);
88
89 static void debug_to_open (char *, int);
90
91 static void debug_to_close (int);
92
93 static void debug_to_attach (char *, int);
94
95 static void debug_to_detach (char *, int);
96
97 static void debug_to_disconnect (char *, int);
98
99 static void debug_to_resume (ptid_t, int, enum target_signal);
100
101 static ptid_t debug_to_wait (ptid_t, struct target_waitstatus *);
102
103 static void debug_to_fetch_registers (int);
104
105 static void debug_to_store_registers (int);
106
107 static void debug_to_prepare_to_store (void);
108
109 static int debug_to_xfer_memory (CORE_ADDR, char *, int, int,
110 struct mem_attrib *, struct target_ops *);
111
112 static void debug_to_files_info (struct target_ops *);
113
114 static int debug_to_insert_breakpoint (CORE_ADDR, char *);
115
116 static int debug_to_remove_breakpoint (CORE_ADDR, char *);
117
118 static int debug_to_can_use_hw_breakpoint (int, int, int);
119
120 static int debug_to_insert_hw_breakpoint (CORE_ADDR, char *);
121
122 static int debug_to_remove_hw_breakpoint (CORE_ADDR, char *);
123
124 static int debug_to_insert_watchpoint (CORE_ADDR, int, int);
125
126 static int debug_to_remove_watchpoint (CORE_ADDR, int, int);
127
128 static int debug_to_stopped_by_watchpoint (void);
129
130 static CORE_ADDR debug_to_stopped_data_address (void);
131
132 static int debug_to_region_size_ok_for_hw_watchpoint (int);
133
134 static void debug_to_terminal_init (void);
135
136 static void debug_to_terminal_inferior (void);
137
138 static void debug_to_terminal_ours_for_output (void);
139
140 static void debug_to_terminal_save_ours (void);
141
142 static void debug_to_terminal_ours (void);
143
144 static void debug_to_terminal_info (char *, int);
145
146 static void debug_to_kill (void);
147
148 static void debug_to_load (char *, int);
149
150 static int debug_to_lookup_symbol (char *, CORE_ADDR *);
151
152 static void debug_to_mourn_inferior (void);
153
154 static int debug_to_can_run (void);
155
156 static void debug_to_notice_signals (ptid_t);
157
158 static int debug_to_thread_alive (ptid_t);
159
160 static void debug_to_stop (void);
161
162 /* Pointer to array of target architecture structures; the size of the
163 array; the current index into the array; the allocated size of the
164 array. */
165 struct target_ops **target_structs;
166 unsigned target_struct_size;
167 unsigned target_struct_index;
168 unsigned target_struct_allocsize;
169 #define DEFAULT_ALLOCSIZE 10
170
171 /* The initial current target, so that there is always a semi-valid
172 current target. */
173
174 static struct target_ops dummy_target;
175
176 /* Top of target stack. */
177
178 static struct target_ops *target_stack;
179
180 /* The target structure we are currently using to talk to a process
181 or file or whatever "inferior" we have. */
182
183 struct target_ops current_target;
184
185 /* Command list for target. */
186
187 static struct cmd_list_element *targetlist = NULL;
188
189 /* Nonzero if we are debugging an attached outside process
190 rather than an inferior. */
191
192 int attach_flag;
193
194 /* Non-zero if we want to see trace of target level stuff. */
195
196 static int targetdebug = 0;
197
198 static void setup_target_debug (void);
199
200 DCACHE *target_dcache;
201
202 /* The user just typed 'target' without the name of a target. */
203
204 static void
205 target_command (char *arg, int from_tty)
206 {
207 fputs_filtered ("Argument required (target name). Try `help target'\n",
208 gdb_stdout);
209 }
210
211 /* Add a possible target architecture to the list. */
212
213 void
214 add_target (struct target_ops *t)
215 {
216 /* Provide default values for all "must have" methods. */
217 if (t->to_xfer_partial == NULL)
218 t->to_xfer_partial = default_xfer_partial;
219
220 if (!target_structs)
221 {
222 target_struct_allocsize = DEFAULT_ALLOCSIZE;
223 target_structs = (struct target_ops **) xmalloc
224 (target_struct_allocsize * sizeof (*target_structs));
225 }
226 if (target_struct_size >= target_struct_allocsize)
227 {
228 target_struct_allocsize *= 2;
229 target_structs = (struct target_ops **)
230 xrealloc ((char *) target_structs,
231 target_struct_allocsize * sizeof (*target_structs));
232 }
233 target_structs[target_struct_size++] = t;
234
235 if (targetlist == NULL)
236 add_prefix_cmd ("target", class_run, target_command,
237 "Connect to a target machine or process.\n\
238 The first argument is the type or protocol of the target machine.\n\
239 Remaining arguments are interpreted by the target protocol. For more\n\
240 information on the arguments for a particular protocol, type\n\
241 `help target ' followed by the protocol name.",
242 &targetlist, "target ", 0, &cmdlist);
243 add_cmd (t->to_shortname, no_class, t->to_open, t->to_doc, &targetlist);
244 }
245
246 /* Stub functions */
247
248 void
249 target_ignore (void)
250 {
251 }
252
253 void
254 target_load (char *arg, int from_tty)
255 {
256 dcache_invalidate (target_dcache);
257 (*current_target.to_load) (arg, from_tty);
258 }
259
260 static int
261 nomemory (CORE_ADDR memaddr, char *myaddr, int len, int write,
262 struct target_ops *t)
263 {
264 errno = EIO; /* Can't read/write this location */
265 return 0; /* No bytes handled */
266 }
267
268 static void
269 tcomplain (void)
270 {
271 error ("You can't do that when your target is `%s'",
272 current_target.to_shortname);
273 }
274
275 void
276 noprocess (void)
277 {
278 error ("You can't do that without a process to debug.");
279 }
280
281 static int
282 nosymbol (char *name, CORE_ADDR *addrp)
283 {
284 return 1; /* Symbol does not exist in target env */
285 }
286
287 static void
288 nosupport_runtime (void)
289 {
290 if (ptid_equal (inferior_ptid, null_ptid))
291 noprocess ();
292 else
293 error ("No run-time support for this");
294 }
295
296
297 static void
298 default_terminal_info (char *args, int from_tty)
299 {
300 printf_unfiltered ("No saved terminal information.\n");
301 }
302
303 /* This is the default target_create_inferior and target_attach function.
304 If the current target is executing, it asks whether to kill it off.
305 If this function returns without calling error(), it has killed off
306 the target, and the operation should be attempted. */
307
308 static void
309 kill_or_be_killed (int from_tty)
310 {
311 if (target_has_execution)
312 {
313 printf_unfiltered ("You are already running a program:\n");
314 target_files_info ();
315 if (query ("Kill it? "))
316 {
317 target_kill ();
318 if (target_has_execution)
319 error ("Killing the program did not help.");
320 return;
321 }
322 else
323 {
324 error ("Program not killed.");
325 }
326 }
327 tcomplain ();
328 }
329
330 static void
331 maybe_kill_then_attach (char *args, int from_tty)
332 {
333 kill_or_be_killed (from_tty);
334 target_attach (args, from_tty);
335 }
336
337 static void
338 maybe_kill_then_create_inferior (char *exec, char *args, char **env,
339 int from_tty)
340 {
341 kill_or_be_killed (0);
342 target_create_inferior (exec, args, env, from_tty);
343 }
344
345 /* Go through the target stack from top to bottom, copying over zero
346 entries in current_target, then filling in still empty entries. In
347 effect, we are doing class inheritance through the pushed target
348 vectors.
349
350 NOTE: cagney/2003-10-17: The problem with this inheritance, as it
351 is currently implemented, is that it discards any knowledge of
352 which target an inherited method originally belonged to.
353 Consequently, new new target methods should instead explicitly and
354 locally search the target stack for the target that can handle the
355 request. */
356
357 static void
358 update_current_target (void)
359 {
360 struct target_ops *t;
361
362 /* First, reset curren'ts contents. */
363 memset (&current_target, 0, sizeof (current_target));
364
365 #define INHERIT(FIELD, TARGET) \
366 if (!current_target.FIELD) \
367 current_target.FIELD = (TARGET)->FIELD
368
369 for (t = target_stack; t; t = t->beneath)
370 {
371 INHERIT (to_shortname, t);
372 INHERIT (to_longname, t);
373 INHERIT (to_doc, t);
374 INHERIT (to_open, t);
375 INHERIT (to_close, t);
376 INHERIT (to_attach, t);
377 INHERIT (to_post_attach, t);
378 INHERIT (to_detach, t);
379 INHERIT (to_disconnect, t);
380 INHERIT (to_resume, t);
381 INHERIT (to_wait, t);
382 INHERIT (to_post_wait, t);
383 INHERIT (to_fetch_registers, t);
384 INHERIT (to_store_registers, t);
385 INHERIT (to_prepare_to_store, t);
386 INHERIT (to_xfer_memory, t);
387 INHERIT (to_files_info, t);
388 INHERIT (to_insert_breakpoint, t);
389 INHERIT (to_remove_breakpoint, t);
390 INHERIT (to_can_use_hw_breakpoint, t);
391 INHERIT (to_insert_hw_breakpoint, t);
392 INHERIT (to_remove_hw_breakpoint, t);
393 INHERIT (to_insert_watchpoint, t);
394 INHERIT (to_remove_watchpoint, t);
395 INHERIT (to_stopped_data_address, t);
396 INHERIT (to_stopped_by_watchpoint, t);
397 INHERIT (to_have_continuable_watchpoint, t);
398 INHERIT (to_region_size_ok_for_hw_watchpoint, t);
399 INHERIT (to_terminal_init, t);
400 INHERIT (to_terminal_inferior, t);
401 INHERIT (to_terminal_ours_for_output, t);
402 INHERIT (to_terminal_ours, t);
403 INHERIT (to_terminal_save_ours, t);
404 INHERIT (to_terminal_info, t);
405 INHERIT (to_kill, t);
406 INHERIT (to_load, t);
407 INHERIT (to_lookup_symbol, t);
408 INHERIT (to_create_inferior, t);
409 INHERIT (to_post_startup_inferior, t);
410 INHERIT (to_acknowledge_created_inferior, t);
411 INHERIT (to_insert_fork_catchpoint, t);
412 INHERIT (to_remove_fork_catchpoint, t);
413 INHERIT (to_insert_vfork_catchpoint, t);
414 INHERIT (to_remove_vfork_catchpoint, t);
415 INHERIT (to_follow_fork, t);
416 INHERIT (to_insert_exec_catchpoint, t);
417 INHERIT (to_remove_exec_catchpoint, t);
418 INHERIT (to_reported_exec_events_per_exec_call, t);
419 INHERIT (to_has_exited, t);
420 INHERIT (to_mourn_inferior, t);
421 INHERIT (to_can_run, t);
422 INHERIT (to_notice_signals, t);
423 INHERIT (to_thread_alive, t);
424 INHERIT (to_find_new_threads, t);
425 INHERIT (to_pid_to_str, t);
426 INHERIT (to_extra_thread_info, t);
427 INHERIT (to_stop, t);
428 /* Do not inherit to_xfer_partial. */
429 INHERIT (to_rcmd, t);
430 INHERIT (to_enable_exception_callback, t);
431 INHERIT (to_get_current_exception_event, t);
432 INHERIT (to_pid_to_exec_file, t);
433 INHERIT (to_stratum, t);
434 INHERIT (to_has_all_memory, t);
435 INHERIT (to_has_memory, t);
436 INHERIT (to_has_stack, t);
437 INHERIT (to_has_registers, t);
438 INHERIT (to_has_execution, t);
439 INHERIT (to_has_thread_control, t);
440 INHERIT (to_sections, t);
441 INHERIT (to_sections_end, t);
442 INHERIT (to_can_async_p, t);
443 INHERIT (to_is_async_p, t);
444 INHERIT (to_async, t);
445 INHERIT (to_async_mask_value, t);
446 INHERIT (to_find_memory_regions, t);
447 INHERIT (to_make_corefile_notes, t);
448 INHERIT (to_get_thread_local_address, t);
449 INHERIT (to_magic, t);
450 }
451 #undef INHERIT
452
453 /* Clean up a target struct so it no longer has any zero pointers in
454 it. Some entries are defaulted to a method that print an error,
455 others are hard-wired to a standard recursive default. */
456
457 #define de_fault(field, value) \
458 if (!current_target.field) \
459 current_target.field = value
460
461 de_fault (to_open,
462 (void (*) (char *, int))
463 tcomplain);
464 de_fault (to_close,
465 (void (*) (int))
466 target_ignore);
467 de_fault (to_attach,
468 maybe_kill_then_attach);
469 de_fault (to_post_attach,
470 (void (*) (int))
471 target_ignore);
472 de_fault (to_detach,
473 (void (*) (char *, int))
474 target_ignore);
475 de_fault (to_disconnect,
476 (void (*) (char *, int))
477 tcomplain);
478 de_fault (to_resume,
479 (void (*) (ptid_t, int, enum target_signal))
480 noprocess);
481 de_fault (to_wait,
482 (ptid_t (*) (ptid_t, struct target_waitstatus *))
483 noprocess);
484 de_fault (to_post_wait,
485 (void (*) (ptid_t, int))
486 target_ignore);
487 de_fault (to_fetch_registers,
488 (void (*) (int))
489 target_ignore);
490 de_fault (to_store_registers,
491 (void (*) (int))
492 noprocess);
493 de_fault (to_prepare_to_store,
494 (void (*) (void))
495 noprocess);
496 de_fault (to_xfer_memory,
497 (int (*) (CORE_ADDR, char *, int, int, struct mem_attrib *, struct target_ops *))
498 nomemory);
499 de_fault (to_files_info,
500 (void (*) (struct target_ops *))
501 target_ignore);
502 de_fault (to_insert_breakpoint,
503 memory_insert_breakpoint);
504 de_fault (to_remove_breakpoint,
505 memory_remove_breakpoint);
506 de_fault (to_can_use_hw_breakpoint,
507 (int (*) (int, int, int))
508 return_zero);
509 de_fault (to_insert_hw_breakpoint,
510 (int (*) (CORE_ADDR, char *))
511 return_minus_one);
512 de_fault (to_remove_hw_breakpoint,
513 (int (*) (CORE_ADDR, char *))
514 return_minus_one);
515 de_fault (to_insert_watchpoint,
516 (int (*) (CORE_ADDR, int, int))
517 return_minus_one);
518 de_fault (to_remove_watchpoint,
519 (int (*) (CORE_ADDR, int, int))
520 return_minus_one);
521 de_fault (to_stopped_by_watchpoint,
522 (int (*) (void))
523 return_zero);
524 de_fault (to_stopped_data_address,
525 (CORE_ADDR (*) (void))
526 return_zero);
527 de_fault (to_region_size_ok_for_hw_watchpoint,
528 default_region_size_ok_for_hw_watchpoint);
529 de_fault (to_terminal_init,
530 (void (*) (void))
531 target_ignore);
532 de_fault (to_terminal_inferior,
533 (void (*) (void))
534 target_ignore);
535 de_fault (to_terminal_ours_for_output,
536 (void (*) (void))
537 target_ignore);
538 de_fault (to_terminal_ours,
539 (void (*) (void))
540 target_ignore);
541 de_fault (to_terminal_save_ours,
542 (void (*) (void))
543 target_ignore);
544 de_fault (to_terminal_info,
545 default_terminal_info);
546 de_fault (to_kill,
547 (void (*) (void))
548 noprocess);
549 de_fault (to_load,
550 (void (*) (char *, int))
551 tcomplain);
552 de_fault (to_lookup_symbol,
553 (int (*) (char *, CORE_ADDR *))
554 nosymbol);
555 de_fault (to_create_inferior,
556 maybe_kill_then_create_inferior);
557 de_fault (to_post_startup_inferior,
558 (void (*) (ptid_t))
559 target_ignore);
560 de_fault (to_acknowledge_created_inferior,
561 (void (*) (int))
562 target_ignore);
563 de_fault (to_insert_fork_catchpoint,
564 (int (*) (int))
565 tcomplain);
566 de_fault (to_remove_fork_catchpoint,
567 (int (*) (int))
568 tcomplain);
569 de_fault (to_insert_vfork_catchpoint,
570 (int (*) (int))
571 tcomplain);
572 de_fault (to_remove_vfork_catchpoint,
573 (int (*) (int))
574 tcomplain);
575 de_fault (to_follow_fork,
576 (int (*) (int))
577 target_ignore);
578 de_fault (to_insert_exec_catchpoint,
579 (int (*) (int))
580 tcomplain);
581 de_fault (to_remove_exec_catchpoint,
582 (int (*) (int))
583 tcomplain);
584 de_fault (to_reported_exec_events_per_exec_call,
585 (int (*) (void))
586 return_one);
587 de_fault (to_has_exited,
588 (int (*) (int, int, int *))
589 return_zero);
590 de_fault (to_mourn_inferior,
591 (void (*) (void))
592 noprocess);
593 de_fault (to_can_run,
594 return_zero);
595 de_fault (to_notice_signals,
596 (void (*) (ptid_t))
597 target_ignore);
598 de_fault (to_thread_alive,
599 (int (*) (ptid_t))
600 return_zero);
601 de_fault (to_find_new_threads,
602 (void (*) (void))
603 target_ignore);
604 de_fault (to_extra_thread_info,
605 (char *(*) (struct thread_info *))
606 return_zero);
607 de_fault (to_stop,
608 (void (*) (void))
609 target_ignore);
610 current_target.to_xfer_partial = default_xfer_partial;
611 de_fault (to_rcmd,
612 (void (*) (char *, struct ui_file *))
613 tcomplain);
614 de_fault (to_enable_exception_callback,
615 (struct symtab_and_line * (*) (enum exception_event_kind, int))
616 nosupport_runtime);
617 de_fault (to_get_current_exception_event,
618 (struct exception_event_record * (*) (void))
619 nosupport_runtime);
620 de_fault (to_pid_to_exec_file,
621 (char *(*) (int))
622 return_zero);
623 de_fault (to_can_async_p,
624 (int (*) (void))
625 return_zero);
626 de_fault (to_is_async_p,
627 (int (*) (void))
628 return_zero);
629 de_fault (to_async,
630 (void (*) (void (*) (enum inferior_event_type, void*), void*))
631 tcomplain);
632 #undef de_fault
633
634 /* Finally, position the target-stack beneath the squashed
635 "current_target". That way code looking for a non-inherited
636 target method can quickly and simply find it. */
637 current_target.beneath = target_stack;
638 }
639
640 /* Push a new target type into the stack of the existing target accessors,
641 possibly superseding some of the existing accessors.
642
643 Result is zero if the pushed target ended up on top of the stack,
644 nonzero if at least one target is on top of it.
645
646 Rather than allow an empty stack, we always have the dummy target at
647 the bottom stratum, so we can call the function vectors without
648 checking them. */
649
650 int
651 push_target (struct target_ops *t)
652 {
653 struct target_ops **cur;
654
655 /* Check magic number. If wrong, it probably means someone changed
656 the struct definition, but not all the places that initialize one. */
657 if (t->to_magic != OPS_MAGIC)
658 {
659 fprintf_unfiltered (gdb_stderr,
660 "Magic number of %s target struct wrong\n",
661 t->to_shortname);
662 internal_error (__FILE__, __LINE__, "failed internal consistency check");
663 }
664
665 /* Find the proper stratum to install this target in. */
666 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
667 {
668 if ((int) (t->to_stratum) >= (int) (*cur)->to_stratum)
669 break;
670 }
671
672 /* If there's already targets at this stratum, remove them. */
673 /* FIXME: cagney/2003-10-15: I think this should be poping all
674 targets to CUR, and not just those at this stratum level. */
675 while ((*cur) != NULL && t->to_stratum == (*cur)->to_stratum)
676 {
677 /* There's already something at this stratum level. Close it,
678 and un-hook it from the stack. */
679 struct target_ops *tmp = (*cur);
680 (*cur) = (*cur)->beneath;
681 tmp->beneath = NULL;
682 target_close (tmp, 0);
683 }
684
685 /* We have removed all targets in our stratum, now add the new one. */
686 t->beneath = (*cur);
687 (*cur) = t;
688
689 update_current_target ();
690
691 if (targetdebug)
692 setup_target_debug ();
693
694 /* Not on top? */
695 return (t != target_stack);
696 }
697
698 /* Remove a target_ops vector from the stack, wherever it may be.
699 Return how many times it was removed (0 or 1). */
700
701 int
702 unpush_target (struct target_ops *t)
703 {
704 struct target_ops **cur;
705 struct target_ops *tmp;
706
707 /* Look for the specified target. Note that we assume that a target
708 can only occur once in the target stack. */
709
710 for (cur = &target_stack; (*cur) != NULL; cur = &(*cur)->beneath)
711 {
712 if ((*cur) == t)
713 break;
714 }
715
716 if ((*cur) == NULL)
717 return 0; /* Didn't find target_ops, quit now */
718
719 /* NOTE: cagney/2003-12-06: In '94 the close call was made
720 unconditional by moving it to before the above check that the
721 target was in the target stack (something about "Change the way
722 pushing and popping of targets work to support target overlays
723 and inheritance"). This doesn't make much sense - only open
724 targets should be closed. */
725 target_close (t, 0);
726
727 /* Unchain the target */
728 tmp = (*cur);
729 (*cur) = (*cur)->beneath;
730 tmp->beneath = NULL;
731
732 update_current_target ();
733
734 return 1;
735 }
736
737 void
738 pop_target (void)
739 {
740 target_close (&current_target, 0); /* Let it clean up */
741 if (unpush_target (target_stack) == 1)
742 return;
743
744 fprintf_unfiltered (gdb_stderr,
745 "pop_target couldn't find target %s\n",
746 current_target.to_shortname);
747 internal_error (__FILE__, __LINE__, "failed internal consistency check");
748 }
749
750 #undef MIN
751 #define MIN(A, B) (((A) <= (B)) ? (A) : (B))
752
753 /* target_read_string -- read a null terminated string, up to LEN bytes,
754 from MEMADDR in target. Set *ERRNOP to the errno code, or 0 if successful.
755 Set *STRING to a pointer to malloc'd memory containing the data; the caller
756 is responsible for freeing it. Return the number of bytes successfully
757 read. */
758
759 int
760 target_read_string (CORE_ADDR memaddr, char **string, int len, int *errnop)
761 {
762 int tlen, origlen, offset, i;
763 char buf[4];
764 int errcode = 0;
765 char *buffer;
766 int buffer_allocated;
767 char *bufptr;
768 unsigned int nbytes_read = 0;
769
770 /* Small for testing. */
771 buffer_allocated = 4;
772 buffer = xmalloc (buffer_allocated);
773 bufptr = buffer;
774
775 origlen = len;
776
777 while (len > 0)
778 {
779 tlen = MIN (len, 4 - (memaddr & 3));
780 offset = memaddr & 3;
781
782 errcode = target_xfer_memory (memaddr & ~3, buf, 4, 0);
783 if (errcode != 0)
784 {
785 /* The transfer request might have crossed the boundary to an
786 unallocated region of memory. Retry the transfer, requesting
787 a single byte. */
788 tlen = 1;
789 offset = 0;
790 errcode = target_xfer_memory (memaddr, buf, 1, 0);
791 if (errcode != 0)
792 goto done;
793 }
794
795 if (bufptr - buffer + tlen > buffer_allocated)
796 {
797 unsigned int bytes;
798 bytes = bufptr - buffer;
799 buffer_allocated *= 2;
800 buffer = xrealloc (buffer, buffer_allocated);
801 bufptr = buffer + bytes;
802 }
803
804 for (i = 0; i < tlen; i++)
805 {
806 *bufptr++ = buf[i + offset];
807 if (buf[i + offset] == '\000')
808 {
809 nbytes_read += i + 1;
810 goto done;
811 }
812 }
813
814 memaddr += tlen;
815 len -= tlen;
816 nbytes_read += tlen;
817 }
818 done:
819 if (errnop != NULL)
820 *errnop = errcode;
821 if (string != NULL)
822 *string = buffer;
823 return nbytes_read;
824 }
825
826 /* Find a section containing ADDR. */
827 struct section_table *
828 target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
829 {
830 struct section_table *secp;
831 for (secp = target->to_sections;
832 secp < target->to_sections_end;
833 secp++)
834 {
835 if (addr >= secp->addr && addr < secp->endaddr)
836 return secp;
837 }
838 return NULL;
839 }
840
841 /* Read LEN bytes of target memory at address MEMADDR, placing the results in
842 GDB's memory at MYADDR. Returns either 0 for success or an errno value
843 if any error occurs.
844
845 If an error occurs, no guarantee is made about the contents of the data at
846 MYADDR. In particular, the caller should not depend upon partial reads
847 filling the buffer with good data. There is no way for the caller to know
848 how much good data might have been transfered anyway. Callers that can
849 deal with partial reads should call target_read_memory_partial. */
850
851 int
852 target_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
853 {
854 return target_xfer_memory (memaddr, myaddr, len, 0);
855 }
856
857 int
858 target_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
859 {
860 return target_xfer_memory (memaddr, myaddr, len, 1);
861 }
862
863 static int trust_readonly = 0;
864
865 /* Move memory to or from the targets. The top target gets priority;
866 if it cannot handle it, it is offered to the next one down, etc.
867
868 Result is -1 on error, or the number of bytes transfered. */
869
870 int
871 do_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
872 struct mem_attrib *attrib)
873 {
874 int res;
875 int done = 0;
876 struct target_ops *t;
877
878 /* Zero length requests are ok and require no work. */
879 if (len == 0)
880 return 0;
881
882 /* to_xfer_memory is not guaranteed to set errno, even when it returns
883 0. */
884 errno = 0;
885
886 if (!write && trust_readonly)
887 {
888 struct section_table *secp;
889 /* User-settable option, "trust-readonly-sections". If true,
890 then memory from any SEC_READONLY bfd section may be read
891 directly from the bfd file. */
892 secp = target_section_by_addr (&current_target, memaddr);
893 if (secp != NULL
894 && (bfd_get_section_flags (secp->bfd, secp->the_bfd_section)
895 & SEC_READONLY))
896 return xfer_memory (memaddr, myaddr, len, 0, attrib, &current_target);
897 }
898
899 /* The quick case is that the top target can handle the transfer. */
900 res = current_target.to_xfer_memory
901 (memaddr, myaddr, len, write, attrib, &current_target);
902
903 /* If res <= 0 then we call it again in the loop. Ah well. */
904 if (res <= 0)
905 {
906 for (t = target_stack; t != NULL; t = t->beneath)
907 {
908 if (!t->to_has_memory)
909 continue;
910
911 res = t->to_xfer_memory (memaddr, myaddr, len, write, attrib, t);
912 if (res > 0)
913 break; /* Handled all or part of xfer */
914 if (t->to_has_all_memory)
915 break;
916 }
917
918 if (res <= 0)
919 return -1;
920 }
921
922 return res;
923 }
924
925
926 /* Perform a memory transfer. Iterate until the entire region has
927 been transfered.
928
929 Result is 0 or errno value. */
930
931 static int
932 target_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write)
933 {
934 int res;
935 int reg_len;
936 struct mem_region *region;
937
938 /* Zero length requests are ok and require no work. */
939 if (len == 0)
940 {
941 return 0;
942 }
943
944 while (len > 0)
945 {
946 region = lookup_mem_region(memaddr);
947 if (memaddr + len < region->hi)
948 reg_len = len;
949 else
950 reg_len = region->hi - memaddr;
951
952 switch (region->attrib.mode)
953 {
954 case MEM_RO:
955 if (write)
956 return EIO;
957 break;
958
959 case MEM_WO:
960 if (!write)
961 return EIO;
962 break;
963 }
964
965 while (reg_len > 0)
966 {
967 if (region->attrib.cache)
968 res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
969 reg_len, write);
970 else
971 res = do_xfer_memory (memaddr, myaddr, reg_len, write,
972 &region->attrib);
973
974 if (res <= 0)
975 {
976 /* If this address is for nonexistent memory, read zeros
977 if reading, or do nothing if writing. Return
978 error. */
979 if (!write)
980 memset (myaddr, 0, len);
981 if (errno == 0)
982 return EIO;
983 else
984 return errno;
985 }
986
987 memaddr += res;
988 myaddr += res;
989 len -= res;
990 reg_len -= res;
991 }
992 }
993
994 return 0; /* We managed to cover it all somehow. */
995 }
996
997
998 /* Perform a partial memory transfer.
999
1000 Result is -1 on error, or the number of bytes transfered. */
1001
1002 static int
1003 target_xfer_memory_partial (CORE_ADDR memaddr, char *myaddr, int len,
1004 int write_p, int *err)
1005 {
1006 int res;
1007 int reg_len;
1008 struct mem_region *region;
1009
1010 /* Zero length requests are ok and require no work. */
1011 if (len == 0)
1012 {
1013 *err = 0;
1014 return 0;
1015 }
1016
1017 region = lookup_mem_region(memaddr);
1018 if (memaddr + len < region->hi)
1019 reg_len = len;
1020 else
1021 reg_len = region->hi - memaddr;
1022
1023 switch (region->attrib.mode)
1024 {
1025 case MEM_RO:
1026 if (write_p)
1027 {
1028 *err = EIO;
1029 return -1;
1030 }
1031 break;
1032
1033 case MEM_WO:
1034 if (write_p)
1035 {
1036 *err = EIO;
1037 return -1;
1038 }
1039 break;
1040 }
1041
1042 if (region->attrib.cache)
1043 res = dcache_xfer_memory (target_dcache, memaddr, myaddr,
1044 reg_len, write_p);
1045 else
1046 res = do_xfer_memory (memaddr, myaddr, reg_len, write_p,
1047 &region->attrib);
1048
1049 if (res <= 0)
1050 {
1051 if (errno != 0)
1052 *err = errno;
1053 else
1054 *err = EIO;
1055
1056 return -1;
1057 }
1058
1059 *err = 0;
1060 return res;
1061 }
1062
1063 int
1064 target_read_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1065 {
1066 return target_xfer_memory_partial (memaddr, buf, len, 0, err);
1067 }
1068
1069 int
1070 target_write_memory_partial (CORE_ADDR memaddr, char *buf, int len, int *err)
1071 {
1072 return target_xfer_memory_partial (memaddr, buf, len, 1, err);
1073 }
1074
1075 /* More generic transfers. */
1076
1077 static LONGEST
1078 default_xfer_partial (struct target_ops *ops, enum target_object object,
1079 const char *annex, void *readbuf,
1080 const void *writebuf, ULONGEST offset, LONGEST len)
1081 {
1082 if (object == TARGET_OBJECT_MEMORY
1083 && ops->to_xfer_memory != NULL)
1084 /* If available, fall back to the target's "to_xfer_memory"
1085 method. */
1086 {
1087 int xfered = -1;
1088 errno = 0;
1089 if (writebuf != NULL)
1090 {
1091 void *buffer = xmalloc (len);
1092 struct cleanup *cleanup = make_cleanup (xfree, buffer);
1093 memcpy (buffer, writebuf, len);
1094 xfered = ops->to_xfer_memory (offset, buffer, len, 1/*write*/, NULL,
1095 ops);
1096 do_cleanups (cleanup);
1097 }
1098 if (readbuf != NULL)
1099 xfered = ops->to_xfer_memory (offset, readbuf, len, 0/*read*/, NULL,
1100 ops);
1101 if (xfered > 0)
1102 return xfered;
1103 else if (xfered == 0 && errno == 0)
1104 /* "to_xfer_memory" uses 0, cross checked against ERRNO as one
1105 indication of an error. */
1106 return 0;
1107 else
1108 return -1;
1109 }
1110 else if (ops->beneath != NULL)
1111 return ops->beneath->to_xfer_partial (ops->beneath, object, annex,
1112 readbuf, writebuf, offset, len);
1113 else
1114 return -1;
1115 }
1116
1117 /* Target vector read/write partial wrapper functions.
1118
1119 NOTE: cagney/2003-10-21: I wonder if having "to_xfer_partial
1120 (inbuf, outbuf)", instead of separate read/write methods, make life
1121 easier. */
1122
1123 LONGEST
1124 target_read_partial (struct target_ops *ops,
1125 enum target_object object,
1126 const char *annex, void *buf,
1127 ULONGEST offset, LONGEST len)
1128 {
1129 gdb_assert (ops->to_xfer_partial != NULL);
1130 return ops->to_xfer_partial (ops, object, annex, buf, NULL, offset, len);
1131 }
1132
1133 LONGEST
1134 target_write_partial (struct target_ops *ops,
1135 enum target_object object,
1136 const char *annex, const void *buf,
1137 ULONGEST offset, LONGEST len)
1138 {
1139 gdb_assert (ops->to_xfer_partial != NULL);
1140 return ops->to_xfer_partial (ops, object, annex, NULL, buf, offset, len);
1141 }
1142
1143 /* Wrappers to perform the full transfer. */
1144 LONGEST
1145 target_read (struct target_ops *ops,
1146 enum target_object object,
1147 const char *annex, void *buf,
1148 ULONGEST offset, LONGEST len)
1149 {
1150 LONGEST xfered = 0;
1151 while (xfered < len)
1152 {
1153 LONGEST xfer = target_read_partial (ops, object, annex,
1154 (bfd_byte *) buf + xfered,
1155 offset + xfered, len - xfered);
1156 /* Call an observer, notifying them of the xfer progress? */
1157 if (xfer <= 0)
1158 /* Call memory_error? */
1159 return -1;
1160 xfered += xfer;
1161 QUIT;
1162 }
1163 return len;
1164 }
1165
1166 LONGEST
1167 target_write (struct target_ops *ops,
1168 enum target_object object,
1169 const char *annex, const void *buf,
1170 ULONGEST offset, LONGEST len)
1171 {
1172 LONGEST xfered = 0;
1173 while (xfered < len)
1174 {
1175 LONGEST xfer = target_write_partial (ops, object, annex,
1176 (bfd_byte *) buf + xfered,
1177 offset + xfered, len - xfered);
1178 /* Call an observer, notifying them of the xfer progress? */
1179 if (xfer <= 0)
1180 /* Call memory_error? */
1181 return -1;
1182 xfered += xfer;
1183 QUIT;
1184 }
1185 return len;
1186 }
1187
1188 /* Memory transfer methods. */
1189
1190 void
1191 get_target_memory (struct target_ops *ops, CORE_ADDR addr, void *buf,
1192 LONGEST len)
1193 {
1194 if (target_read (ops, TARGET_OBJECT_MEMORY, NULL, buf, addr, len)
1195 != len)
1196 memory_error (EIO, addr);
1197 }
1198
1199 ULONGEST
1200 get_target_memory_unsigned (struct target_ops *ops,
1201 CORE_ADDR addr, int len)
1202 {
1203 char buf[sizeof (ULONGEST)];
1204
1205 gdb_assert (len <= sizeof (buf));
1206 get_target_memory (ops, addr, buf, len);
1207 return extract_unsigned_integer (buf, len);
1208 }
1209
1210 static void
1211 target_info (char *args, int from_tty)
1212 {
1213 struct target_ops *t;
1214 int has_all_mem = 0;
1215
1216 if (symfile_objfile != NULL)
1217 printf_unfiltered ("Symbols from \"%s\".\n", symfile_objfile->name);
1218
1219 #ifdef FILES_INFO_HOOK
1220 if (FILES_INFO_HOOK ())
1221 return;
1222 #endif
1223
1224 for (t = target_stack; t != NULL; t = t->beneath)
1225 {
1226 if (!t->to_has_memory)
1227 continue;
1228
1229 if ((int) (t->to_stratum) <= (int) dummy_stratum)
1230 continue;
1231 if (has_all_mem)
1232 printf_unfiltered ("\tWhile running this, GDB does not access memory from...\n");
1233 printf_unfiltered ("%s:\n", t->to_longname);
1234 (t->to_files_info) (t);
1235 has_all_mem = t->to_has_all_memory;
1236 }
1237 }
1238
1239 /* This is to be called by the open routine before it does
1240 anything. */
1241
1242 void
1243 target_preopen (int from_tty)
1244 {
1245 dont_repeat ();
1246
1247 if (target_has_execution)
1248 {
1249 if (!from_tty
1250 || query ("A program is being debugged already. Kill it? "))
1251 target_kill ();
1252 else
1253 error ("Program not killed.");
1254 }
1255
1256 /* Calling target_kill may remove the target from the stack. But if
1257 it doesn't (which seems like a win for UDI), remove it now. */
1258
1259 if (target_has_execution)
1260 pop_target ();
1261 }
1262
1263 /* Detach a target after doing deferred register stores. */
1264
1265 void
1266 target_detach (char *args, int from_tty)
1267 {
1268 (current_target.to_detach) (args, from_tty);
1269 }
1270
1271 void
1272 target_disconnect (char *args, int from_tty)
1273 {
1274 (current_target.to_disconnect) (args, from_tty);
1275 }
1276
1277 void
1278 target_link (char *modname, CORE_ADDR *t_reloc)
1279 {
1280 if (DEPRECATED_STREQ (current_target.to_shortname, "rombug"))
1281 {
1282 (current_target.to_lookup_symbol) (modname, t_reloc);
1283 if (*t_reloc == 0)
1284 error ("Unable to link to %s and get relocation in rombug", modname);
1285 }
1286 else
1287 *t_reloc = (CORE_ADDR) -1;
1288 }
1289
1290 int
1291 target_async_mask (int mask)
1292 {
1293 int saved_async_masked_status = target_async_mask_value;
1294 target_async_mask_value = mask;
1295 return saved_async_masked_status;
1296 }
1297
1298 /* Look through the list of possible targets for a target that can
1299 execute a run or attach command without any other data. This is
1300 used to locate the default process stratum.
1301
1302 Result is always valid (error() is called for errors). */
1303
1304 static struct target_ops *
1305 find_default_run_target (char *do_mesg)
1306 {
1307 struct target_ops **t;
1308 struct target_ops *runable = NULL;
1309 int count;
1310
1311 count = 0;
1312
1313 for (t = target_structs; t < target_structs + target_struct_size;
1314 ++t)
1315 {
1316 if ((*t)->to_can_run && target_can_run (*t))
1317 {
1318 runable = *t;
1319 ++count;
1320 }
1321 }
1322
1323 if (count != 1)
1324 error ("Don't know how to %s. Try \"help target\".", do_mesg);
1325
1326 return runable;
1327 }
1328
1329 void
1330 find_default_attach (char *args, int from_tty)
1331 {
1332 struct target_ops *t;
1333
1334 t = find_default_run_target ("attach");
1335 (t->to_attach) (args, from_tty);
1336 return;
1337 }
1338
1339 void
1340 find_default_create_inferior (char *exec_file, char *allargs, char **env,
1341 int from_tty)
1342 {
1343 struct target_ops *t;
1344
1345 t = find_default_run_target ("run");
1346 (t->to_create_inferior) (exec_file, allargs, env, from_tty);
1347 return;
1348 }
1349
1350 static int
1351 default_region_size_ok_for_hw_watchpoint (int byte_count)
1352 {
1353 return (byte_count <= TYPE_LENGTH (builtin_type_void_data_ptr));
1354 }
1355
1356 static int
1357 return_zero (void)
1358 {
1359 return 0;
1360 }
1361
1362 static int
1363 return_one (void)
1364 {
1365 return 1;
1366 }
1367
1368 static int
1369 return_minus_one (void)
1370 {
1371 return -1;
1372 }
1373
1374 /*
1375 * Resize the to_sections pointer. Also make sure that anyone that
1376 * was holding on to an old value of it gets updated.
1377 * Returns the old size.
1378 */
1379
1380 int
1381 target_resize_to_sections (struct target_ops *target, int num_added)
1382 {
1383 struct target_ops **t;
1384 struct section_table *old_value;
1385 int old_count;
1386
1387 old_value = target->to_sections;
1388
1389 if (target->to_sections)
1390 {
1391 old_count = target->to_sections_end - target->to_sections;
1392 target->to_sections = (struct section_table *)
1393 xrealloc ((char *) target->to_sections,
1394 (sizeof (struct section_table)) * (num_added + old_count));
1395 }
1396 else
1397 {
1398 old_count = 0;
1399 target->to_sections = (struct section_table *)
1400 xmalloc ((sizeof (struct section_table)) * num_added);
1401 }
1402 target->to_sections_end = target->to_sections + (num_added + old_count);
1403
1404 /* Check to see if anyone else was pointing to this structure.
1405 If old_value was null, then no one was. */
1406
1407 if (old_value)
1408 {
1409 for (t = target_structs; t < target_structs + target_struct_size;
1410 ++t)
1411 {
1412 if ((*t)->to_sections == old_value)
1413 {
1414 (*t)->to_sections = target->to_sections;
1415 (*t)->to_sections_end = target->to_sections_end;
1416 }
1417 }
1418 }
1419
1420 return old_count;
1421
1422 }
1423
1424 /* Remove all target sections taken from ABFD.
1425
1426 Scan the current target stack for targets whose section tables
1427 refer to sections from BFD, and remove those sections. We use this
1428 when we notice that the inferior has unloaded a shared object, for
1429 example. */
1430 void
1431 remove_target_sections (bfd *abfd)
1432 {
1433 struct target_ops **t;
1434
1435 for (t = target_structs; t < target_structs + target_struct_size; t++)
1436 {
1437 struct section_table *src, *dest;
1438
1439 dest = (*t)->to_sections;
1440 for (src = (*t)->to_sections; src < (*t)->to_sections_end; src++)
1441 if (src->bfd != abfd)
1442 {
1443 /* Keep this section. */
1444 if (dest < src) *dest = *src;
1445 dest++;
1446 }
1447
1448 /* If we've dropped any sections, resize the section table. */
1449 if (dest < src)
1450 target_resize_to_sections (*t, dest - src);
1451 }
1452 }
1453
1454
1455
1456
1457 /* Find a single runnable target in the stack and return it. If for
1458 some reason there is more than one, return NULL. */
1459
1460 struct target_ops *
1461 find_run_target (void)
1462 {
1463 struct target_ops **t;
1464 struct target_ops *runable = NULL;
1465 int count;
1466
1467 count = 0;
1468
1469 for (t = target_structs; t < target_structs + target_struct_size; ++t)
1470 {
1471 if ((*t)->to_can_run && target_can_run (*t))
1472 {
1473 runable = *t;
1474 ++count;
1475 }
1476 }
1477
1478 return (count == 1 ? runable : NULL);
1479 }
1480
1481 /* Find a single core_stratum target in the list of targets and return it.
1482 If for some reason there is more than one, return NULL. */
1483
1484 struct target_ops *
1485 find_core_target (void)
1486 {
1487 struct target_ops **t;
1488 struct target_ops *runable = NULL;
1489 int count;
1490
1491 count = 0;
1492
1493 for (t = target_structs; t < target_structs + target_struct_size;
1494 ++t)
1495 {
1496 if ((*t)->to_stratum == core_stratum)
1497 {
1498 runable = *t;
1499 ++count;
1500 }
1501 }
1502
1503 return (count == 1 ? runable : NULL);
1504 }
1505
1506 /*
1507 * Find the next target down the stack from the specified target.
1508 */
1509
1510 struct target_ops *
1511 find_target_beneath (struct target_ops *t)
1512 {
1513 return t->beneath;
1514 }
1515
1516 \f
1517 /* The inferior process has died. Long live the inferior! */
1518
1519 void
1520 generic_mourn_inferior (void)
1521 {
1522 extern int show_breakpoint_hit_counts;
1523
1524 inferior_ptid = null_ptid;
1525 attach_flag = 0;
1526 breakpoint_init_inferior (inf_exited);
1527 registers_changed ();
1528
1529 #ifdef CLEAR_DEFERRED_STORES
1530 /* Delete any pending stores to the inferior... */
1531 CLEAR_DEFERRED_STORES;
1532 #endif
1533
1534 reopen_exec_file ();
1535 reinit_frame_cache ();
1536
1537 /* It is confusing to the user for ignore counts to stick around
1538 from previous runs of the inferior. So clear them. */
1539 /* However, it is more confusing for the ignore counts to disappear when
1540 using hit counts. So don't clear them if we're counting hits. */
1541 if (!show_breakpoint_hit_counts)
1542 breakpoint_clear_ignore_counts ();
1543
1544 if (deprecated_detach_hook)
1545 deprecated_detach_hook ();
1546 }
1547 \f
1548 /* Helper function for child_wait and the Lynx derivatives of child_wait.
1549 HOSTSTATUS is the waitstatus from wait() or the equivalent; store our
1550 translation of that in OURSTATUS. */
1551 void
1552 store_waitstatus (struct target_waitstatus *ourstatus, int hoststatus)
1553 {
1554 #ifdef CHILD_SPECIAL_WAITSTATUS
1555 /* CHILD_SPECIAL_WAITSTATUS should return nonzero and set *OURSTATUS
1556 if it wants to deal with hoststatus. */
1557 if (CHILD_SPECIAL_WAITSTATUS (ourstatus, hoststatus))
1558 return;
1559 #endif
1560
1561 if (WIFEXITED (hoststatus))
1562 {
1563 ourstatus->kind = TARGET_WAITKIND_EXITED;
1564 ourstatus->value.integer = WEXITSTATUS (hoststatus);
1565 }
1566 else if (!WIFSTOPPED (hoststatus))
1567 {
1568 ourstatus->kind = TARGET_WAITKIND_SIGNALLED;
1569 ourstatus->value.sig = target_signal_from_host (WTERMSIG (hoststatus));
1570 }
1571 else
1572 {
1573 ourstatus->kind = TARGET_WAITKIND_STOPPED;
1574 ourstatus->value.sig = target_signal_from_host (WSTOPSIG (hoststatus));
1575 }
1576 }
1577 \f
1578 /* Returns zero to leave the inferior alone, one to interrupt it. */
1579 int (*target_activity_function) (void);
1580 int target_activity_fd;
1581 \f
1582 /* Convert a normal process ID to a string. Returns the string in a static
1583 buffer. */
1584
1585 char *
1586 normal_pid_to_str (ptid_t ptid)
1587 {
1588 static char buf[30];
1589
1590 sprintf (buf, "process %d", PIDGET (ptid));
1591 return buf;
1592 }
1593
1594 /* Error-catcher for target_find_memory_regions */
1595 static int dummy_find_memory_regions (int (*ignore1) (), void *ignore2)
1596 {
1597 error ("No target.");
1598 return 0;
1599 }
1600
1601 /* Error-catcher for target_make_corefile_notes */
1602 static char * dummy_make_corefile_notes (bfd *ignore1, int *ignore2)
1603 {
1604 error ("No target.");
1605 return NULL;
1606 }
1607
1608 /* Set up the handful of non-empty slots needed by the dummy target
1609 vector. */
1610
1611 static void
1612 init_dummy_target (void)
1613 {
1614 dummy_target.to_shortname = "None";
1615 dummy_target.to_longname = "None";
1616 dummy_target.to_doc = "";
1617 dummy_target.to_attach = find_default_attach;
1618 dummy_target.to_create_inferior = find_default_create_inferior;
1619 dummy_target.to_pid_to_str = normal_pid_to_str;
1620 dummy_target.to_stratum = dummy_stratum;
1621 dummy_target.to_find_memory_regions = dummy_find_memory_regions;
1622 dummy_target.to_make_corefile_notes = dummy_make_corefile_notes;
1623 dummy_target.to_xfer_partial = default_xfer_partial;
1624 dummy_target.to_magic = OPS_MAGIC;
1625 }
1626 \f
1627
1628 static struct target_ops debug_target;
1629
1630 static void
1631 debug_to_open (char *args, int from_tty)
1632 {
1633 debug_target.to_open (args, from_tty);
1634
1635 fprintf_unfiltered (gdb_stdlog, "target_open (%s, %d)\n", args, from_tty);
1636 }
1637
1638 static void
1639 debug_to_close (int quitting)
1640 {
1641 target_close (&debug_target, quitting);
1642 fprintf_unfiltered (gdb_stdlog, "target_close (%d)\n", quitting);
1643 }
1644
1645 void
1646 target_close (struct target_ops *targ, int quitting)
1647 {
1648 if (targ->to_xclose != NULL)
1649 targ->to_xclose (targ, quitting);
1650 else if (targ->to_close != NULL)
1651 targ->to_close (quitting);
1652 }
1653
1654 static void
1655 debug_to_attach (char *args, int from_tty)
1656 {
1657 debug_target.to_attach (args, from_tty);
1658
1659 fprintf_unfiltered (gdb_stdlog, "target_attach (%s, %d)\n", args, from_tty);
1660 }
1661
1662
1663 static void
1664 debug_to_post_attach (int pid)
1665 {
1666 debug_target.to_post_attach (pid);
1667
1668 fprintf_unfiltered (gdb_stdlog, "target_post_attach (%d)\n", pid);
1669 }
1670
1671 static void
1672 debug_to_detach (char *args, int from_tty)
1673 {
1674 debug_target.to_detach (args, from_tty);
1675
1676 fprintf_unfiltered (gdb_stdlog, "target_detach (%s, %d)\n", args, from_tty);
1677 }
1678
1679 static void
1680 debug_to_disconnect (char *args, int from_tty)
1681 {
1682 debug_target.to_disconnect (args, from_tty);
1683
1684 fprintf_unfiltered (gdb_stdlog, "target_disconnect (%s, %d)\n",
1685 args, from_tty);
1686 }
1687
1688 static void
1689 debug_to_resume (ptid_t ptid, int step, enum target_signal siggnal)
1690 {
1691 debug_target.to_resume (ptid, step, siggnal);
1692
1693 fprintf_unfiltered (gdb_stdlog, "target_resume (%d, %s, %s)\n", PIDGET (ptid),
1694 step ? "step" : "continue",
1695 target_signal_to_name (siggnal));
1696 }
1697
1698 static ptid_t
1699 debug_to_wait (ptid_t ptid, struct target_waitstatus *status)
1700 {
1701 ptid_t retval;
1702
1703 retval = debug_target.to_wait (ptid, status);
1704
1705 fprintf_unfiltered (gdb_stdlog,
1706 "target_wait (%d, status) = %d, ", PIDGET (ptid),
1707 PIDGET (retval));
1708 fprintf_unfiltered (gdb_stdlog, "status->kind = ");
1709 switch (status->kind)
1710 {
1711 case TARGET_WAITKIND_EXITED:
1712 fprintf_unfiltered (gdb_stdlog, "exited, status = %d\n",
1713 status->value.integer);
1714 break;
1715 case TARGET_WAITKIND_STOPPED:
1716 fprintf_unfiltered (gdb_stdlog, "stopped, signal = %s\n",
1717 target_signal_to_name (status->value.sig));
1718 break;
1719 case TARGET_WAITKIND_SIGNALLED:
1720 fprintf_unfiltered (gdb_stdlog, "signalled, signal = %s\n",
1721 target_signal_to_name (status->value.sig));
1722 break;
1723 case TARGET_WAITKIND_LOADED:
1724 fprintf_unfiltered (gdb_stdlog, "loaded\n");
1725 break;
1726 case TARGET_WAITKIND_FORKED:
1727 fprintf_unfiltered (gdb_stdlog, "forked\n");
1728 break;
1729 case TARGET_WAITKIND_VFORKED:
1730 fprintf_unfiltered (gdb_stdlog, "vforked\n");
1731 break;
1732 case TARGET_WAITKIND_EXECD:
1733 fprintf_unfiltered (gdb_stdlog, "execd\n");
1734 break;
1735 case TARGET_WAITKIND_SPURIOUS:
1736 fprintf_unfiltered (gdb_stdlog, "spurious\n");
1737 break;
1738 default:
1739 fprintf_unfiltered (gdb_stdlog, "unknown???\n");
1740 break;
1741 }
1742
1743 return retval;
1744 }
1745
1746 static void
1747 debug_to_post_wait (ptid_t ptid, int status)
1748 {
1749 debug_target.to_post_wait (ptid, status);
1750
1751 fprintf_unfiltered (gdb_stdlog, "target_post_wait (%d, %d)\n",
1752 PIDGET (ptid), status);
1753 }
1754
1755 static void
1756 debug_print_register (const char * func, int regno)
1757 {
1758 fprintf_unfiltered (gdb_stdlog, "%s ", func);
1759 if (regno >= 0 && regno < NUM_REGS + NUM_PSEUDO_REGS
1760 && REGISTER_NAME (regno) != NULL && REGISTER_NAME (regno)[0] != '\0')
1761 fprintf_unfiltered (gdb_stdlog, "(%s)", REGISTER_NAME (regno));
1762 else
1763 fprintf_unfiltered (gdb_stdlog, "(%d)", regno);
1764 if (regno >= 0)
1765 {
1766 int i;
1767 unsigned char buf[MAX_REGISTER_SIZE];
1768 deprecated_read_register_gen (regno, buf);
1769 fprintf_unfiltered (gdb_stdlog, " = ");
1770 for (i = 0; i < DEPRECATED_REGISTER_RAW_SIZE (regno); i++)
1771 {
1772 fprintf_unfiltered (gdb_stdlog, "%02x", buf[i]);
1773 }
1774 if (DEPRECATED_REGISTER_RAW_SIZE (regno) <= sizeof (LONGEST))
1775 {
1776 fprintf_unfiltered (gdb_stdlog, " 0x%s %s",
1777 paddr_nz (read_register (regno)),
1778 paddr_d (read_register (regno)));
1779 }
1780 }
1781 fprintf_unfiltered (gdb_stdlog, "\n");
1782 }
1783
1784 static void
1785 debug_to_fetch_registers (int regno)
1786 {
1787 debug_target.to_fetch_registers (regno);
1788 debug_print_register ("target_fetch_registers", regno);
1789 }
1790
1791 static void
1792 debug_to_store_registers (int regno)
1793 {
1794 debug_target.to_store_registers (regno);
1795 debug_print_register ("target_store_registers", regno);
1796 fprintf_unfiltered (gdb_stdlog, "\n");
1797 }
1798
1799 static void
1800 debug_to_prepare_to_store (void)
1801 {
1802 debug_target.to_prepare_to_store ();
1803
1804 fprintf_unfiltered (gdb_stdlog, "target_prepare_to_store ()\n");
1805 }
1806
1807 static int
1808 debug_to_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
1809 struct mem_attrib *attrib,
1810 struct target_ops *target)
1811 {
1812 int retval;
1813
1814 retval = debug_target.to_xfer_memory (memaddr, myaddr, len, write,
1815 attrib, target);
1816
1817 fprintf_unfiltered (gdb_stdlog,
1818 "target_xfer_memory (0x%x, xxx, %d, %s, xxx) = %d",
1819 (unsigned int) memaddr, /* possable truncate long long */
1820 len, write ? "write" : "read", retval);
1821
1822 if (retval > 0)
1823 {
1824 int i;
1825
1826 fputs_unfiltered (", bytes =", gdb_stdlog);
1827 for (i = 0; i < retval; i++)
1828 {
1829 if ((((long) &(myaddr[i])) & 0xf) == 0)
1830 {
1831 if (targetdebug < 2 && i > 0)
1832 {
1833 fprintf_unfiltered (gdb_stdlog, " ...");
1834 break;
1835 }
1836 fprintf_unfiltered (gdb_stdlog, "\n");
1837 }
1838
1839 fprintf_unfiltered (gdb_stdlog, " %02x", myaddr[i] & 0xff);
1840 }
1841 }
1842
1843 fputc_unfiltered ('\n', gdb_stdlog);
1844
1845 return retval;
1846 }
1847
1848 static void
1849 debug_to_files_info (struct target_ops *target)
1850 {
1851 debug_target.to_files_info (target);
1852
1853 fprintf_unfiltered (gdb_stdlog, "target_files_info (xxx)\n");
1854 }
1855
1856 static int
1857 debug_to_insert_breakpoint (CORE_ADDR addr, char *save)
1858 {
1859 int retval;
1860
1861 retval = debug_target.to_insert_breakpoint (addr, save);
1862
1863 fprintf_unfiltered (gdb_stdlog,
1864 "target_insert_breakpoint (0x%lx, xxx) = %ld\n",
1865 (unsigned long) addr,
1866 (unsigned long) retval);
1867 return retval;
1868 }
1869
1870 static int
1871 debug_to_remove_breakpoint (CORE_ADDR addr, char *save)
1872 {
1873 int retval;
1874
1875 retval = debug_target.to_remove_breakpoint (addr, save);
1876
1877 fprintf_unfiltered (gdb_stdlog,
1878 "target_remove_breakpoint (0x%lx, xxx) = %ld\n",
1879 (unsigned long) addr,
1880 (unsigned long) retval);
1881 return retval;
1882 }
1883
1884 static int
1885 debug_to_can_use_hw_breakpoint (int type, int cnt, int from_tty)
1886 {
1887 int retval;
1888
1889 retval = debug_target.to_can_use_hw_breakpoint (type, cnt, from_tty);
1890
1891 fprintf_unfiltered (gdb_stdlog,
1892 "target_can_use_hw_breakpoint (%ld, %ld, %ld) = %ld\n",
1893 (unsigned long) type,
1894 (unsigned long) cnt,
1895 (unsigned long) from_tty,
1896 (unsigned long) retval);
1897 return retval;
1898 }
1899
1900 static int
1901 debug_to_region_size_ok_for_hw_watchpoint (int byte_count)
1902 {
1903 CORE_ADDR retval;
1904
1905 retval = debug_target.to_region_size_ok_for_hw_watchpoint (byte_count);
1906
1907 fprintf_unfiltered (gdb_stdlog,
1908 "TARGET_REGION_SIZE_OK_FOR_HW_WATCHPOINT (%ld) = 0x%lx\n",
1909 (unsigned long) byte_count,
1910 (unsigned long) retval);
1911 return retval;
1912 }
1913
1914 static int
1915 debug_to_stopped_by_watchpoint (void)
1916 {
1917 int retval;
1918
1919 retval = debug_target.to_stopped_by_watchpoint ();
1920
1921 fprintf_unfiltered (gdb_stdlog,
1922 "STOPPED_BY_WATCHPOINT () = %ld\n",
1923 (unsigned long) retval);
1924 return retval;
1925 }
1926
1927 static CORE_ADDR
1928 debug_to_stopped_data_address (void)
1929 {
1930 CORE_ADDR retval;
1931
1932 retval = debug_target.to_stopped_data_address ();
1933
1934 fprintf_unfiltered (gdb_stdlog,
1935 "target_stopped_data_address () = 0x%lx\n",
1936 (unsigned long) retval);
1937 return retval;
1938 }
1939
1940 static int
1941 debug_to_insert_hw_breakpoint (CORE_ADDR addr, char *save)
1942 {
1943 int retval;
1944
1945 retval = debug_target.to_insert_hw_breakpoint (addr, save);
1946
1947 fprintf_unfiltered (gdb_stdlog,
1948 "target_insert_hw_breakpoint (0x%lx, xxx) = %ld\n",
1949 (unsigned long) addr,
1950 (unsigned long) retval);
1951 return retval;
1952 }
1953
1954 static int
1955 debug_to_remove_hw_breakpoint (CORE_ADDR addr, char *save)
1956 {
1957 int retval;
1958
1959 retval = debug_target.to_remove_hw_breakpoint (addr, save);
1960
1961 fprintf_unfiltered (gdb_stdlog,
1962 "target_remove_hw_breakpoint (0x%lx, xxx) = %ld\n",
1963 (unsigned long) addr,
1964 (unsigned long) retval);
1965 return retval;
1966 }
1967
1968 static int
1969 debug_to_insert_watchpoint (CORE_ADDR addr, int len, int type)
1970 {
1971 int retval;
1972
1973 retval = debug_target.to_insert_watchpoint (addr, len, type);
1974
1975 fprintf_unfiltered (gdb_stdlog,
1976 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1977 (unsigned long) addr, len, type, (unsigned long) retval);
1978 return retval;
1979 }
1980
1981 static int
1982 debug_to_remove_watchpoint (CORE_ADDR addr, int len, int type)
1983 {
1984 int retval;
1985
1986 retval = debug_target.to_insert_watchpoint (addr, len, type);
1987
1988 fprintf_unfiltered (gdb_stdlog,
1989 "target_insert_watchpoint (0x%lx, %d, %d) = %ld\n",
1990 (unsigned long) addr, len, type, (unsigned long) retval);
1991 return retval;
1992 }
1993
1994 static void
1995 debug_to_terminal_init (void)
1996 {
1997 debug_target.to_terminal_init ();
1998
1999 fprintf_unfiltered (gdb_stdlog, "target_terminal_init ()\n");
2000 }
2001
2002 static void
2003 debug_to_terminal_inferior (void)
2004 {
2005 debug_target.to_terminal_inferior ();
2006
2007 fprintf_unfiltered (gdb_stdlog, "target_terminal_inferior ()\n");
2008 }
2009
2010 static void
2011 debug_to_terminal_ours_for_output (void)
2012 {
2013 debug_target.to_terminal_ours_for_output ();
2014
2015 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours_for_output ()\n");
2016 }
2017
2018 static void
2019 debug_to_terminal_ours (void)
2020 {
2021 debug_target.to_terminal_ours ();
2022
2023 fprintf_unfiltered (gdb_stdlog, "target_terminal_ours ()\n");
2024 }
2025
2026 static void
2027 debug_to_terminal_save_ours (void)
2028 {
2029 debug_target.to_terminal_save_ours ();
2030
2031 fprintf_unfiltered (gdb_stdlog, "target_terminal_save_ours ()\n");
2032 }
2033
2034 static void
2035 debug_to_terminal_info (char *arg, int from_tty)
2036 {
2037 debug_target.to_terminal_info (arg, from_tty);
2038
2039 fprintf_unfiltered (gdb_stdlog, "target_terminal_info (%s, %d)\n", arg,
2040 from_tty);
2041 }
2042
2043 static void
2044 debug_to_kill (void)
2045 {
2046 debug_target.to_kill ();
2047
2048 fprintf_unfiltered (gdb_stdlog, "target_kill ()\n");
2049 }
2050
2051 static void
2052 debug_to_load (char *args, int from_tty)
2053 {
2054 debug_target.to_load (args, from_tty);
2055
2056 fprintf_unfiltered (gdb_stdlog, "target_load (%s, %d)\n", args, from_tty);
2057 }
2058
2059 static int
2060 debug_to_lookup_symbol (char *name, CORE_ADDR *addrp)
2061 {
2062 int retval;
2063
2064 retval = debug_target.to_lookup_symbol (name, addrp);
2065
2066 fprintf_unfiltered (gdb_stdlog, "target_lookup_symbol (%s, xxx)\n", name);
2067
2068 return retval;
2069 }
2070
2071 static void
2072 debug_to_create_inferior (char *exec_file, char *args, char **env,
2073 int from_tty)
2074 {
2075 debug_target.to_create_inferior (exec_file, args, env, from_tty);
2076
2077 fprintf_unfiltered (gdb_stdlog, "target_create_inferior (%s, %s, xxx, %d)\n",
2078 exec_file, args, from_tty);
2079 }
2080
2081 static void
2082 debug_to_post_startup_inferior (ptid_t ptid)
2083 {
2084 debug_target.to_post_startup_inferior (ptid);
2085
2086 fprintf_unfiltered (gdb_stdlog, "target_post_startup_inferior (%d)\n",
2087 PIDGET (ptid));
2088 }
2089
2090 static void
2091 debug_to_acknowledge_created_inferior (int pid)
2092 {
2093 debug_target.to_acknowledge_created_inferior (pid);
2094
2095 fprintf_unfiltered (gdb_stdlog, "target_acknowledge_created_inferior (%d)\n",
2096 pid);
2097 }
2098
2099 static int
2100 debug_to_insert_fork_catchpoint (int pid)
2101 {
2102 int retval;
2103
2104 retval = debug_target.to_insert_fork_catchpoint (pid);
2105
2106 fprintf_unfiltered (gdb_stdlog, "target_insert_fork_catchpoint (%d) = %d\n",
2107 pid, retval);
2108
2109 return retval;
2110 }
2111
2112 static int
2113 debug_to_remove_fork_catchpoint (int pid)
2114 {
2115 int retval;
2116
2117 retval = debug_target.to_remove_fork_catchpoint (pid);
2118
2119 fprintf_unfiltered (gdb_stdlog, "target_remove_fork_catchpoint (%d) = %d\n",
2120 pid, retval);
2121
2122 return retval;
2123 }
2124
2125 static int
2126 debug_to_insert_vfork_catchpoint (int pid)
2127 {
2128 int retval;
2129
2130 retval = debug_target.to_insert_vfork_catchpoint (pid);
2131
2132 fprintf_unfiltered (gdb_stdlog, "target_insert_vfork_catchpoint (%d)= %d\n",
2133 pid, retval);
2134
2135 return retval;
2136 }
2137
2138 static int
2139 debug_to_remove_vfork_catchpoint (int pid)
2140 {
2141 int retval;
2142
2143 retval = debug_target.to_remove_vfork_catchpoint (pid);
2144
2145 fprintf_unfiltered (gdb_stdlog, "target_remove_vfork_catchpoint (%d) = %d\n",
2146 pid, retval);
2147
2148 return retval;
2149 }
2150
2151 static int
2152 debug_to_follow_fork (int follow_child)
2153 {
2154 int retval = debug_target.to_follow_fork (follow_child);
2155
2156 fprintf_unfiltered (gdb_stdlog, "target_follow_fork (%d) = %d\n",
2157 follow_child, retval);
2158
2159 return retval;
2160 }
2161
2162 static int
2163 debug_to_insert_exec_catchpoint (int pid)
2164 {
2165 int retval;
2166
2167 retval = debug_target.to_insert_exec_catchpoint (pid);
2168
2169 fprintf_unfiltered (gdb_stdlog, "target_insert_exec_catchpoint (%d) = %d\n",
2170 pid, retval);
2171
2172 return retval;
2173 }
2174
2175 static int
2176 debug_to_remove_exec_catchpoint (int pid)
2177 {
2178 int retval;
2179
2180 retval = debug_target.to_remove_exec_catchpoint (pid);
2181
2182 fprintf_unfiltered (gdb_stdlog, "target_remove_exec_catchpoint (%d) = %d\n",
2183 pid, retval);
2184
2185 return retval;
2186 }
2187
2188 static int
2189 debug_to_reported_exec_events_per_exec_call (void)
2190 {
2191 int reported_exec_events;
2192
2193 reported_exec_events = debug_target.to_reported_exec_events_per_exec_call ();
2194
2195 fprintf_unfiltered (gdb_stdlog,
2196 "target_reported_exec_events_per_exec_call () = %d\n",
2197 reported_exec_events);
2198
2199 return reported_exec_events;
2200 }
2201
2202 static int
2203 debug_to_has_exited (int pid, int wait_status, int *exit_status)
2204 {
2205 int has_exited;
2206
2207 has_exited = debug_target.to_has_exited (pid, wait_status, exit_status);
2208
2209 fprintf_unfiltered (gdb_stdlog, "target_has_exited (%d, %d, %d) = %d\n",
2210 pid, wait_status, *exit_status, has_exited);
2211
2212 return has_exited;
2213 }
2214
2215 static void
2216 debug_to_mourn_inferior (void)
2217 {
2218 debug_target.to_mourn_inferior ();
2219
2220 fprintf_unfiltered (gdb_stdlog, "target_mourn_inferior ()\n");
2221 }
2222
2223 static int
2224 debug_to_can_run (void)
2225 {
2226 int retval;
2227
2228 retval = debug_target.to_can_run ();
2229
2230 fprintf_unfiltered (gdb_stdlog, "target_can_run () = %d\n", retval);
2231
2232 return retval;
2233 }
2234
2235 static void
2236 debug_to_notice_signals (ptid_t ptid)
2237 {
2238 debug_target.to_notice_signals (ptid);
2239
2240 fprintf_unfiltered (gdb_stdlog, "target_notice_signals (%d)\n",
2241 PIDGET (ptid));
2242 }
2243
2244 static int
2245 debug_to_thread_alive (ptid_t ptid)
2246 {
2247 int retval;
2248
2249 retval = debug_target.to_thread_alive (ptid);
2250
2251 fprintf_unfiltered (gdb_stdlog, "target_thread_alive (%d) = %d\n",
2252 PIDGET (ptid), retval);
2253
2254 return retval;
2255 }
2256
2257 static void
2258 debug_to_find_new_threads (void)
2259 {
2260 debug_target.to_find_new_threads ();
2261
2262 fputs_unfiltered ("target_find_new_threads ()\n", gdb_stdlog);
2263 }
2264
2265 static void
2266 debug_to_stop (void)
2267 {
2268 debug_target.to_stop ();
2269
2270 fprintf_unfiltered (gdb_stdlog, "target_stop ()\n");
2271 }
2272
2273 static LONGEST
2274 debug_to_xfer_partial (struct target_ops *ops, enum target_object object,
2275 const char *annex, void *readbuf, const void *writebuf,
2276 ULONGEST offset, LONGEST len)
2277 {
2278 LONGEST retval;
2279
2280 retval = debug_target.to_xfer_partial (&debug_target, object, annex,
2281 readbuf, writebuf, offset, len);
2282
2283 fprintf_unfiltered (gdb_stdlog,
2284 "target_xfer_partial (%d, %s, 0x%lx, 0x%lx, 0x%s, %s) = %s\n",
2285 (int) object, (annex ? annex : "(null)"),
2286 (long) readbuf, (long) writebuf, paddr_nz (offset),
2287 paddr_d (len), paddr_d (retval));
2288
2289 return retval;
2290 }
2291
2292 static void
2293 debug_to_rcmd (char *command,
2294 struct ui_file *outbuf)
2295 {
2296 debug_target.to_rcmd (command, outbuf);
2297 fprintf_unfiltered (gdb_stdlog, "target_rcmd (%s, ...)\n", command);
2298 }
2299
2300 static struct symtab_and_line *
2301 debug_to_enable_exception_callback (enum exception_event_kind kind, int enable)
2302 {
2303 struct symtab_and_line *result;
2304 result = debug_target.to_enable_exception_callback (kind, enable);
2305 fprintf_unfiltered (gdb_stdlog,
2306 "target get_exception_callback_sal (%d, %d)\n",
2307 kind, enable);
2308 return result;
2309 }
2310
2311 static struct exception_event_record *
2312 debug_to_get_current_exception_event (void)
2313 {
2314 struct exception_event_record *result;
2315 result = debug_target.to_get_current_exception_event ();
2316 fprintf_unfiltered (gdb_stdlog, "target get_current_exception_event ()\n");
2317 return result;
2318 }
2319
2320 static char *
2321 debug_to_pid_to_exec_file (int pid)
2322 {
2323 char *exec_file;
2324
2325 exec_file = debug_target.to_pid_to_exec_file (pid);
2326
2327 fprintf_unfiltered (gdb_stdlog, "target_pid_to_exec_file (%d) = %s\n",
2328 pid, exec_file);
2329
2330 return exec_file;
2331 }
2332
2333 static void
2334 setup_target_debug (void)
2335 {
2336 memcpy (&debug_target, &current_target, sizeof debug_target);
2337
2338 current_target.to_open = debug_to_open;
2339 current_target.to_close = debug_to_close;
2340 current_target.to_attach = debug_to_attach;
2341 current_target.to_post_attach = debug_to_post_attach;
2342 current_target.to_detach = debug_to_detach;
2343 current_target.to_disconnect = debug_to_disconnect;
2344 current_target.to_resume = debug_to_resume;
2345 current_target.to_wait = debug_to_wait;
2346 current_target.to_post_wait = debug_to_post_wait;
2347 current_target.to_fetch_registers = debug_to_fetch_registers;
2348 current_target.to_store_registers = debug_to_store_registers;
2349 current_target.to_prepare_to_store = debug_to_prepare_to_store;
2350 current_target.to_xfer_memory = debug_to_xfer_memory;
2351 current_target.to_files_info = debug_to_files_info;
2352 current_target.to_insert_breakpoint = debug_to_insert_breakpoint;
2353 current_target.to_remove_breakpoint = debug_to_remove_breakpoint;
2354 current_target.to_can_use_hw_breakpoint = debug_to_can_use_hw_breakpoint;
2355 current_target.to_insert_hw_breakpoint = debug_to_insert_hw_breakpoint;
2356 current_target.to_remove_hw_breakpoint = debug_to_remove_hw_breakpoint;
2357 current_target.to_insert_watchpoint = debug_to_insert_watchpoint;
2358 current_target.to_remove_watchpoint = debug_to_remove_watchpoint;
2359 current_target.to_stopped_by_watchpoint = debug_to_stopped_by_watchpoint;
2360 current_target.to_stopped_data_address = debug_to_stopped_data_address;
2361 current_target.to_region_size_ok_for_hw_watchpoint = debug_to_region_size_ok_for_hw_watchpoint;
2362 current_target.to_terminal_init = debug_to_terminal_init;
2363 current_target.to_terminal_inferior = debug_to_terminal_inferior;
2364 current_target.to_terminal_ours_for_output = debug_to_terminal_ours_for_output;
2365 current_target.to_terminal_ours = debug_to_terminal_ours;
2366 current_target.to_terminal_save_ours = debug_to_terminal_save_ours;
2367 current_target.to_terminal_info = debug_to_terminal_info;
2368 current_target.to_kill = debug_to_kill;
2369 current_target.to_load = debug_to_load;
2370 current_target.to_lookup_symbol = debug_to_lookup_symbol;
2371 current_target.to_create_inferior = debug_to_create_inferior;
2372 current_target.to_post_startup_inferior = debug_to_post_startup_inferior;
2373 current_target.to_acknowledge_created_inferior = debug_to_acknowledge_created_inferior;
2374 current_target.to_insert_fork_catchpoint = debug_to_insert_fork_catchpoint;
2375 current_target.to_remove_fork_catchpoint = debug_to_remove_fork_catchpoint;
2376 current_target.to_insert_vfork_catchpoint = debug_to_insert_vfork_catchpoint;
2377 current_target.to_remove_vfork_catchpoint = debug_to_remove_vfork_catchpoint;
2378 current_target.to_follow_fork = debug_to_follow_fork;
2379 current_target.to_insert_exec_catchpoint = debug_to_insert_exec_catchpoint;
2380 current_target.to_remove_exec_catchpoint = debug_to_remove_exec_catchpoint;
2381 current_target.to_reported_exec_events_per_exec_call = debug_to_reported_exec_events_per_exec_call;
2382 current_target.to_has_exited = debug_to_has_exited;
2383 current_target.to_mourn_inferior = debug_to_mourn_inferior;
2384 current_target.to_can_run = debug_to_can_run;
2385 current_target.to_notice_signals = debug_to_notice_signals;
2386 current_target.to_thread_alive = debug_to_thread_alive;
2387 current_target.to_find_new_threads = debug_to_find_new_threads;
2388 current_target.to_stop = debug_to_stop;
2389 current_target.to_xfer_partial = debug_to_xfer_partial;
2390 current_target.to_rcmd = debug_to_rcmd;
2391 current_target.to_enable_exception_callback = debug_to_enable_exception_callback;
2392 current_target.to_get_current_exception_event = debug_to_get_current_exception_event;
2393 current_target.to_pid_to_exec_file = debug_to_pid_to_exec_file;
2394
2395 }
2396 \f
2397
2398 static char targ_desc[] =
2399 "Names of targets and files being debugged.\n\
2400 Shows the entire stack of targets currently in use (including the exec-file,\n\
2401 core-file, and process, if any), as well as the symbol file name.";
2402
2403 static void
2404 do_monitor_command (char *cmd,
2405 int from_tty)
2406 {
2407 if ((current_target.to_rcmd
2408 == (void (*) (char *, struct ui_file *)) tcomplain)
2409 || (current_target.to_rcmd == debug_to_rcmd
2410 && (debug_target.to_rcmd
2411 == (void (*) (char *, struct ui_file *)) tcomplain)))
2412 {
2413 error ("\"monitor\" command not supported by this target.\n");
2414 }
2415 target_rcmd (cmd, gdb_stdtarg);
2416 }
2417
2418 void
2419 initialize_targets (void)
2420 {
2421 init_dummy_target ();
2422 push_target (&dummy_target);
2423
2424 add_info ("target", target_info, targ_desc);
2425 add_info ("files", target_info, targ_desc);
2426
2427 add_show_from_set
2428 (add_set_cmd ("target", class_maintenance, var_zinteger,
2429 (char *) &targetdebug,
2430 "Set target debugging.\n\
2431 When non-zero, target debugging is enabled. Higher numbers are more\n\
2432 verbose. Changes do not take effect until the next \"run\" or \"target\"\n\
2433 command.", &setdebuglist),
2434 &showdebuglist);
2435
2436 add_setshow_boolean_cmd ("trust-readonly-sections", class_support,
2437 &trust_readonly, "\
2438 Set mode for reading from readonly sections.\n\
2439 When this mode is on, memory reads from readonly sections (such as .text)\n\
2440 will be read from the object file instead of from the target. This will\n\
2441 result in significant performance improvement for remote targets.", "\
2442 Show mode for reading from readonly sections.\n",
2443 NULL, NULL,
2444 &setlist, &showlist);
2445
2446 add_com ("monitor", class_obscure, do_monitor_command,
2447 "Send a command to the remote monitor (remote targets only).");
2448
2449 target_dcache = dcache_init ();
2450 }
This page took 0.079367 seconds and 4 git commands to generate.