GDB (xrefs)

/tmp/gdb-8.1/gdb/corefile.c
Go to the documentation of this file.
1 /* Core dump and executable file functions above target vector, for GDB.
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include <signal.h>
22 #include <fcntl.h>
23 #include "inferior.h"
24 #include "symtab.h"
25 #include "command.h"
26 #include "gdbcmd.h"
27 #include "bfd.h"
28 #include "target.h"
29 #include "gdbcore.h"
30 #include "dis-asm.h"
31 #include <sys/stat.h>
32 #include "completer.h"
33 #include "observer.h"
34 #include "cli/cli-utils.h"
35
36 /* You can have any number of hooks for `exec_file_command' command to
37 call. If there's only one hook, it is set in exec_file_display
38 hook. If there are two or more hooks, they are set in
39 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
40 set to a function that calls all of them. This extra complexity is
41 needed to preserve compatibility with old code that assumed that
42 only one hook could be set, and which called
43 deprecated_exec_file_display_hook directly. */
44
45 typedef void (*hook_type) (const char *);
46
47 hook_type deprecated_exec_file_display_hook; /* The original hook. */
48 static hook_type *exec_file_extra_hooks; /* Array of additional
49 hooks. */
50 static int exec_file_hook_count = 0; /* Size of array. */
51
52 /* Binary file diddling handle for the core file. */
53
54 bfd *core_bfd = NULL;
55
56 /* corelow.c target. It is never NULL after GDB initialization. */
57
58 struct target_ops *core_target;
59
60
61 /* Backward compatability with old way of specifying core files. */
62
63 void
64 core_file_command (const char *filename, int from_tty)
65 {
66 dont_repeat (); /* Either way, seems bogus. */
67
68 gdb_assert (core_target != NULL);
69
70 if (!filename)
71 (core_target->to_detach) (core_target, filename, from_tty);
72 else
73 (core_target->to_open) (filename, from_tty);
74 }
75
76
77 /* If there are two or more functions that wish to hook into
78 exec_file_command, this function will call all of the hook
79 functions. */
80
81 static void
82 call_extra_exec_file_hooks (const char *filename)
83 {
84 int i;
85
86 for (i = 0; i < exec_file_hook_count; i++)
87 (*exec_file_extra_hooks[i]) (filename);
88 }
89
90 /* Call this to specify the hook for exec_file_command to call back.
91 This is called from the x-window display code. */
92
93 void
94 specify_exec_file_hook (void (*hook) (const char *))
95 {
96 hook_type *new_array;
97
98 if (deprecated_exec_file_display_hook != NULL)
99 {
100 /* There's already a hook installed. Arrange to have both it
101 and the subsequent hooks called. */
102 if (exec_file_hook_count == 0)
103 {
104 /* If this is the first extra hook, initialize the hook
105 array. */
106 exec_file_extra_hooks = XNEW (hook_type);
107 exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
108 deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
109 exec_file_hook_count = 1;
110 }
111
112 /* Grow the hook array by one and add the new hook to the end.
113 Yes, it's inefficient to grow it by one each time but since
114 this is hardly ever called it's not a big deal. */
115 exec_file_hook_count++;
116 new_array = (hook_type *)
117 xrealloc (exec_file_extra_hooks,
118 exec_file_hook_count * sizeof (hook_type));
119 exec_file_extra_hooks = new_array;
120 exec_file_extra_hooks[exec_file_hook_count - 1] = hook;
121 }
122 else
123 deprecated_exec_file_display_hook = hook;
124 }
125
126 void
127 reopen_exec_file (void)
128 {
129 int res;
130 struct stat st;
131
132 /* Don't do anything if there isn't an exec file. */
133 if (exec_bfd == NULL)
134 return;
135
136 /* If the timestamp of the exec file has changed, reopen it. */
137 std::string filename = bfd_get_filename (exec_bfd);
138 res = stat (filename.c_str (), &st);
139
140 if (res == 0 && exec_bfd_mtime && exec_bfd_mtime != st.st_mtime)
141 exec_file_attach (filename.c_str (), 0);
142 else
143 /* If we accessed the file since last opening it, close it now;
144 this stops GDB from holding the executable open after it
145 exits. */
146 bfd_cache_close_all ();
147 }
148
149 /* If we have both a core file and an exec file,
150 print a warning if they don't go together. */
151
152 void
153 validate_files (void)
154 {
155 if (exec_bfd && core_bfd)
156 {
157 if (!core_file_matches_executable_p (core_bfd, exec_bfd))
158 warning (_("core file may not match specified executable file."));
159 else if (bfd_get_mtime (exec_bfd) > bfd_get_mtime (core_bfd))
160 warning (_("exec file is newer than core file."));
161 }
162 }
163
164 /* See common/common-inferior.h. */
165
166 char *
167 get_exec_file (int err)
168 {
169 if (exec_filename)
170 return exec_filename;
171 if (!err)
172 return NULL;
173
174 error (_("No executable file specified.\n\
175 Use the \"file\" or \"exec-file\" command."));
176 return NULL;
177 }
178
179
180 std::string
181 memory_error_message (enum target_xfer_status err,
182 struct gdbarch *gdbarch, CORE_ADDR memaddr)
183 {
184 switch (err)
185 {
186 case TARGET_XFER_E_IO:
187 /* Actually, address between memaddr and memaddr + len was out of
188 bounds. */
189 return string_printf (_("Cannot access memory at address %s"),
190 paddress (gdbarch, memaddr));
191 case TARGET_XFER_UNAVAILABLE:
192 return string_printf (_("Memory at address %s unavailable."),
193 paddress (gdbarch, memaddr));
194 default:
195 internal_error (__FILE__, __LINE__,
196 "unhandled target_xfer_status: %s (%s)",
197 target_xfer_status_to_string (err),
198 plongest (err));
199 }
200 }
201
202 /* Report a memory error by throwing a suitable exception. */
203
204 void
205 memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
206 {
207 enum errors exception = GDB_NO_ERROR;
208
209 /* Build error string. */
210 std::string str = memory_error_message (err, target_gdbarch (), memaddr);
211
212 /* Choose the right error to throw. */
213 switch (err)
214 {
215 case TARGET_XFER_E_IO:
216 exception = MEMORY_ERROR;
217 break;
218 case TARGET_XFER_UNAVAILABLE:
219 exception = NOT_AVAILABLE_ERROR;
220 break;
221 }
222
223 /* Throw it. */
224 throw_error (exception, ("%s"), str.c_str ());
225 }
226
227 /* Helper function. */
228
229 static void
230 read_memory_object (enum target_object object, CORE_ADDR memaddr,
231 gdb_byte *myaddr, ssize_t len)
232 {
233 ULONGEST xfered = 0;
234
235 while (xfered < len)
236 {
237 enum target_xfer_status status;
238 ULONGEST xfered_len;
239
240 status = target_xfer_partial (current_target.beneath,
241 object, NULL,
242 myaddr + xfered, NULL,
243 memaddr + xfered, len - xfered,
244 &xfered_len);
245
246 if (status != TARGET_XFER_OK)
247 memory_error (status == TARGET_XFER_EOF ? TARGET_XFER_E_IO : status,
248 memaddr + xfered);
249
250 xfered += xfered_len;
251 QUIT;
252 }
253 }
254
255 /* Same as target_read_memory, but report an error if can't read. */
256
257 void
258 read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
259 {
260 read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len);
261 }
262
263 /* Same as target_read_stack, but report an error if can't read. */
264
265 void
266 read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
267 {
268 read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len);
269 }
270
271 /* Same as target_read_code, but report an error if can't read. */
272
273 void
274 read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
275 {
276 read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len);
277 }
278
279 /* Read memory at MEMADDR of length LEN and put the contents in
280 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
281 if successful. */
282
283 int
284 safe_read_memory_integer (CORE_ADDR memaddr, int len,
285 enum bfd_endian byte_order,
286 LONGEST *return_value)
287 {
288 gdb_byte buf[sizeof (LONGEST)];
289
290 if (target_read_memory (memaddr, buf, len))
291 return 0;
292
293 *return_value = extract_signed_integer (buf, len, byte_order);
294 return 1;
295 }
296
297 /* Read memory at MEMADDR of length LEN and put the contents in
298 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
299 if successful. */
300
301 int
302 safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
303 enum bfd_endian byte_order,
304 ULONGEST *return_value)
305 {
306 gdb_byte buf[sizeof (ULONGEST)];
307
308 if (target_read_memory (memaddr, buf, len))
309 return 0;
310
311 *return_value = extract_unsigned_integer (buf, len, byte_order);
312 return 1;
313 }
314
315 LONGEST
316 read_memory_integer (CORE_ADDR memaddr, int len,
317 enum bfd_endian byte_order)
318 {
319 gdb_byte buf[sizeof (LONGEST)];
320
321 read_memory (memaddr, buf, len);
322 return extract_signed_integer (buf, len, byte_order);
323 }
324
325 ULONGEST
326 read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
327 enum bfd_endian byte_order)
328 {
329 gdb_byte buf[sizeof (ULONGEST)];
330
331 read_memory (memaddr, buf, len);
332 return extract_unsigned_integer (buf, len, byte_order);
333 }
334
335 LONGEST
336 read_code_integer (CORE_ADDR memaddr, int len,
337 enum bfd_endian byte_order)
338 {
339 gdb_byte buf[sizeof (LONGEST)];
340
341 read_code (memaddr, buf, len);
342 return extract_signed_integer (buf, len, byte_order);
343 }
344
345 ULONGEST
346 read_code_unsigned_integer (CORE_ADDR memaddr, int len,
347 enum bfd_endian byte_order)
348 {
349 gdb_byte buf[sizeof (ULONGEST)];
350
351 read_code (memaddr, buf, len);
352 return extract_unsigned_integer (buf, len, byte_order);
353 }
354
355 void
356 read_memory_string (CORE_ADDR memaddr, char *buffer, int max_len)
357 {
358 char *cp;
359 int i;
360 int cnt;
361
362 cp = buffer;
363 while (1)
364 {
365 if (cp - buffer >= max_len)
366 {
367 buffer[max_len - 1] = '\0';
368 break;
369 }
370 cnt = max_len - (cp - buffer);
371 if (cnt > 8)
372 cnt = 8;
373 read_memory (memaddr + (int) (cp - buffer), (gdb_byte *) cp, cnt);
374 for (i = 0; i < cnt && *cp; i++, cp++)
375 ; /* null body */
376
377 if (i < cnt && !*cp)
378 break;
379 }
380 }
381
382 CORE_ADDR
383 read_memory_typed_address (CORE_ADDR addr, struct type *type)
384 {
385 gdb_byte *buf = (gdb_byte *) alloca (TYPE_LENGTH (type));
386
387 read_memory (addr, buf, TYPE_LENGTH (type));
388 return extract_typed_address (buf, type);
389 }
390
391 /* See gdbcore.h. */
392
393 void
394 write_memory (CORE_ADDR memaddr,
395 const bfd_byte *myaddr, ssize_t len)
396 {
397 int status;
398
399 status = target_write_memory (memaddr, myaddr, len);
400 if (status != 0)
401 memory_error (TARGET_XFER_E_IO, memaddr);
402 }
403
404 /* Same as write_memory, but notify 'memory_changed' observers. */
405
406 void
407 write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
408 ssize_t len)
409 {
410 write_memory (memaddr, myaddr, len);
411 observer_notify_memory_changed (current_inferior (), memaddr, len, myaddr);
412 }
413
414 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
415 integer. */
416 void
417 write_memory_unsigned_integer (CORE_ADDR addr, int len,
418 enum bfd_endian byte_order,
419 ULONGEST value)
420 {
421 gdb_byte *buf = (gdb_byte *) alloca (len);
422
423 store_unsigned_integer (buf, len, byte_order, value);
424 write_memory (addr, buf, len);
425 }
426
427 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
428 integer. */
429 void
430 write_memory_signed_integer (CORE_ADDR addr, int len,
431 enum bfd_endian byte_order,
432 LONGEST value)
433 {
434 gdb_byte *buf = (gdb_byte *) alloca (len);
435
436 store_signed_integer (buf, len, byte_order, value);
437 write_memory (addr, buf, len);
438 }
439
440 /* The current default bfd target. Points to storage allocated for
441 gnutarget_string. */
442 char *gnutarget;
443
444 /* Same thing, except it is "auto" not NULL for the default case. */
445 static char *gnutarget_string;
446 static void
447 show_gnutarget_string (struct ui_file *file, int from_tty,
448 struct cmd_list_element *c,
449 const char *value)
450 {
451 fprintf_filtered (file,
452 _("The current BFD target is \"%s\".\n"), value);
453 }
454
455 static void
456 set_gnutarget_command (const char *ignore, int from_tty,
457 struct cmd_list_element *c)
458 {
459 char *gend = gnutarget_string + strlen (gnutarget_string);
460
461 gend = remove_trailing_whitespace (gnutarget_string, gend);
462 *gend = '\0';
463
464 if (strcmp (gnutarget_string, "auto") == 0)
465 gnutarget = NULL;
466 else
467 gnutarget = gnutarget_string;
468 }
469
470 /* A completion function for "set gnutarget". */
471
472 static void
473 complete_set_gnutarget (struct cmd_list_element *cmd,
474 completion_tracker &tracker,
475 const char *text, const char *word)
476 {
477 static const char **bfd_targets;
478
479 if (bfd_targets == NULL)
480 {
481 int last;
482
483 bfd_targets = bfd_target_list ();
484 for (last = 0; bfd_targets[last] != NULL; ++last)
485 ;
486
487 bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
488 bfd_targets[last] = "auto";
489 bfd_targets[last + 1] = NULL;
490 }
491
492 complete_on_enum (tracker, bfd_targets, text, word);
493 }
494
495 /* Set the gnutarget. */
496 void
497 set_gnutarget (const char *newtarget)
498 {
499 if (gnutarget_string != NULL)
500 xfree (gnutarget_string);
501 gnutarget_string = xstrdup (newtarget);
502 set_gnutarget_command (NULL, 0, NULL);
503 }
504
505 void
506 _initialize_core (void)
507 {
508 struct cmd_list_element *c;
509
510 c = add_cmd ("core-file", class_files, core_file_command, _("\
511 Use FILE as core dump for examining memory and registers.\n\
512 No arg means have no core file. This command has been superseded by the\n\
513 `target core' and `detach' commands."), &cmdlist);
514 set_cmd_completer (c, filename_completer);
515
516
517 c = add_setshow_string_noescape_cmd ("gnutarget", class_files,
518 &gnutarget_string, _("\
519 Set the current BFD target."), _("\
520 Show the current BFD target."), _("\
521 Use `set gnutarget auto' to specify automatic detection."),
522 set_gnutarget_command,
523 show_gnutarget_string,
524 &setlist, &showlist);
525 set_cmd_completer (c, complete_set_gnutarget);
526
527 add_alias_cmd ("g", "gnutarget", class_files, 1, &setlist);
528
529 if (getenv ("GNUTARGET"))
530 set_gnutarget (getenv ("GNUTARGET"));
531 else
532 set_gnutarget ("auto");
533 }
target_gdbarch
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5467
err
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1822
gdbarch
Definition: gdbarch.c:127
GDB_NO_ERROR
Definition: common-exceptions.h:50
string
const char * string
Definition: signals.c:50
MEMORY_ERROR
Definition: common-exceptions.h:78
reopen_exec_file
void reopen_exec_file(void)
Definition: corefile.c:127
completer.h
extract_typed_address
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:154
show_gnutarget_string
static void show_gnutarget_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: corefile.c:447
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
read_memory_string
void read_memory_string(CORE_ADDR memaddr, char *buffer, int max_len)
Definition: corefile.c:356
target_write_memory
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1451
command.h
safe_read_memory_unsigned_integer
int safe_read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, ULONGEST *return_value)
Definition: corefile.c:302
xfree
void xfree(void *)
cmd_list_element
Definition: cli-decode.h:46
write_memory_unsigned_integer
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:417
warning
void warning(const char *fmt,...)
Definition: errors.c:26
plongest
char * plongest(LONGEST l)
Definition: print-utils.c:137
exec_bfd_mtime
#define exec_bfd_mtime
Definition: exec.h:34
deprecated_exec_file_display_hook
hook_type deprecated_exec_file_display_hook
Definition: corefile.c:47
complete_on_enum
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
Definition: cli-decode.c:1853
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
safe_read_memory_integer
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition: corefile.c:284
add_cmd
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:262
call_extra_exec_file_hooks
static void call_extra_exec_file_hooks(const char *filename)
Definition: corefile.c:82
filename_completer
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:152
exec_filename
#define exec_filename
Definition: exec.h:35
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
_
#define _(String)
Definition: gdb_locale.h:35
ui_file
Definition: ui-file.h:26
defs.h
TARGET_OBJECT_STACK_MEMORY
Definition: target.h:147
target_xfer_status_to_string
const char * target_xfer_status_to_string(enum target_xfer_status status)
Definition: target.c:883
class_files
Definition: command.h:41
paddress
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2745
XNEW
#define XNEW(T)
Definition: poison.h:109
read_code_unsigned_integer
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:346
observer.h
NOT_AVAILABLE_ERROR
Definition: common-exceptions.h:82
symtab.h
memory_error
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition: corefile.c:205
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
set_gnutarget_command
static void set_gnutarget_command(const char *ignore, int from_tty, struct cmd_list_element *c)
Definition: corefile.c:456
exec_file_hook_count
static int exec_file_hook_count
Definition: corefile.c:50
read_memory_integer
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:316
remove_trailing_whitespace
const char * remove_trailing_whitespace(const char *start, const char *s)
Definition: cli-utils.c:248
gnutarget
char * gnutarget
Definition: corefile.c:442
current_target
struct target_ops current_target
hook_type
void(* hook_type)(const char *)
Definition: corefile.c:45
memory_error_message
std::string memory_error_message(enum target_xfer_status err, struct gdbarch *gdbarch, CORE_ADDR memaddr)
Definition: corefile.c:181
target_ops
Definition: target.h:412
exec_bfd
#define exec_bfd
Definition: exec.h:33
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
TARGET_OBJECT_MEMORY
Definition: target.h:139
set_cmd_completer
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:160
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
set_gnutarget
void set_gnutarget(const char *newtarget)
Definition: corefile.c:497
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
cli-utils.h
add_setshow_string_noescape_cmd
struct cmd_list_element * add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, char **var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:632
inferior.h
write_memory_signed_integer
void write_memory_signed_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, LONGEST value)
Definition: corefile.c:430
TARGET_XFER_OK
Definition: target.h:209
target_xfer_status
target_xfer_status
Definition: target.h:206
exec_file_extra_hooks
static hook_type * exec_file_extra_hooks
Definition: corefile.c:48
type
Definition: gdbtypes.h:749
read_code
void read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:274
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
specify_exec_file_hook
void specify_exec_file_hook(void(*hook)(const char *))
Definition: corefile.c:94
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
target_ops::to_detach
void(* to_detach)(struct target_ops *ops, const char *, int) TARGET_DEFAULT_IGNORE()
Definition: target.h:443
XRESIZEVEC
#define XRESIZEVEC(T, P, N)
Definition: poison.h:169
target_object
target_object
Definition: target.h:132
add_alias_cmd
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *old, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:306
read_code_integer
LONGEST read_code_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:336
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
gnutarget_string
static char * gnutarget_string
Definition: corefile.c:445
core_target
struct target_ops * core_target
Definition: corefile.c:58
value
Definition: value.c:169
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
core_file_command
void core_file_command(const char *filename, int from_tty)
Definition: corefile.c:64
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
exec_file_attach
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:244
gdbcore.h
TARGET_XFER_EOF
Definition: target.h:212
target_read_memory
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1370
read_memory_object
static void read_memory_object(enum target_object object, CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:230
errors
errors
Definition: common-exceptions.h:49
target_ops::to_open
void(* to_open)(const char *, int)
Definition: target.h:426
buffer
Definition: buffer.h:23
validate_files
void validate_files(void)
Definition: corefile.c:153
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
target.h
string_printf
std::string string_printf(const char *fmt,...)
Definition: common-utils.c:150
observer_notify_memory_changed
void observer_notify_memory_changed(struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
current_inferior
struct inferior * current_inferior(void)
Definition: inferior.c:58
get_exec_file
char * get_exec_file(int err)
Definition: corefile.c:167
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
target_xfer_partial
target_xfer_partial_ftype target_xfer_partial
completion_tracker
Definition: completer.h:310
core_bfd
bfd * core_bfd
Definition: corefile.c:54
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
dont_repeat
void dont_repeat(void)
Definition: top.c:695
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
_initialize_core
void _initialize_core(void)
Definition: corefile.c:506
read_memory_typed_address
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
Definition: corefile.c:383
write_memory_with_notification
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:407
QUIT
#define QUIT
Definition: defs.h:179
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
gdbcmd.h
complete_set_gnutarget
static void complete_set_gnutarget(struct cmd_list_element *cmd, completion_tracker &tracker, const char *text, const char *word)
Definition: corefile.c:473
store_signed_integer
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:597
error
void error(const char *fmt,...)
Definition: errors.c:38
read_stack
void read_stack(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:266
TARGET_XFER_E_IO
Definition: target.h:220
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
LONGEST
long long LONGEST
Definition: common-types.h:52
target_ops::beneath
struct target_ops * beneath
Definition: target.h:414
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
TARGET_OBJECT_CODE_MEMORY
Definition: target.h:150
TARGET_XFER_UNAVAILABLE
Definition: target.h:215