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