GDB (xrefs)
Loading...
Searching...
No Matches
/tmp/gdb-13.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-2023 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 "observable.h"
34#include "cli/cli-utils.h"
35#include "gdbarch.h"
36
37/* You can have any number of hooks for `exec_file_command' command to
38 call. If there's only one hook, it is set in exec_file_display
39 hook. If there are two or more hooks, they are set in
40 exec_file_extra_hooks[], and deprecated_exec_file_display_hook is
41 set to a function that calls all of them. This extra complexity is
42 needed to preserve compatibility with old code that assumed that
43 only one hook could be set, and which called
44 deprecated_exec_file_display_hook directly. */
45
46typedef void (*hook_type) (const char *);
47
49static hook_type *exec_file_extra_hooks; /* Array of additional
50 hooks. */
51static int exec_file_hook_count = 0; /* Size of array. */
52
53
54
55/* If there are two or more functions that wish to hook into
56 exec_file_command, this function will call all of the hook
57 functions. */
58
59static void
60call_extra_exec_file_hooks (const char *filename)
61{
62 int i;
63
64 for (i = 0; i < exec_file_hook_count; i++)
65 (*exec_file_extra_hooks[i]) (filename);
66}
67
68/* Call this to specify the hook for exec_file_command to call back.
69 This is called from the x-window display code. */
70
71void
72specify_exec_file_hook (void (*hook) (const char *))
73{
74 hook_type *new_array;
75
77 {
78 /* There's already a hook installed. Arrange to have both it
79 and the subsequent hooks called. */
80 if (exec_file_hook_count == 0)
81 {
82 /* If this is the first extra hook, initialize the hook
83 array. */
88 }
89
90 /* Grow the hook array by one and add the new hook to the end.
91 Yes, it's inefficient to grow it by one each time but since
92 this is hardly ever called it's not a big deal. */
94 new_array = (hook_type *)
97 exec_file_extra_hooks = new_array;
99 }
100 else
102}
103
104void
106{
107 int res;
108 struct stat st;
109
110 /* Don't do anything if there isn't an exec file. */
111 if (current_program_space->exec_bfd () == NULL)
112 return;
113
114 /* If the timestamp of the exec file has changed, reopen it. */
115 std::string filename = bfd_get_filename (current_program_space->exec_bfd ());
116 res = stat (filename.c_str (), &st);
117
118 if (res == 0
120 && current_program_space->ebfd_mtime != st.st_mtime)
121 exec_file_attach (filename.c_str (), 0);
122 else
123 /* If we accessed the file since last opening it, close it now;
124 this stops GDB from holding the executable open after it
125 exits. */
126 bfd_cache_close_all ();
127}
128
129/* If we have both a core file and an exec file,
130 print a warning if they don't go together. */
131
132void
134{
136 {
137 if (!core_file_matches_executable_p (core_bfd,
139 warning (_("core file may not match specified executable file."));
140 else if (bfd_get_mtime (current_program_space->exec_bfd ())
141 > bfd_get_mtime (core_bfd))
142 warning (_("exec file is newer than core file."));
143 }
144}
145
146/* See gdbsupport/common-inferior.h. */
147
148const char *
150{
151 if (current_program_space->exec_filename != nullptr)
153 if (!err)
154 return NULL;
155
156 error (_("No executable file specified.\n\
157Use the \"file\" or \"exec-file\" command."));
158}
159
160
161std::string
163 struct gdbarch *gdbarch, CORE_ADDR memaddr)
164{
165 switch (err)
166 {
167 case TARGET_XFER_E_IO:
168 /* Actually, address between memaddr and memaddr + len was out of
169 bounds. */
170 return string_printf (_("Cannot access memory at address %s"),
171 paddress (gdbarch, memaddr));
173 return string_printf (_("Memory at address %s unavailable."),
174 paddress (gdbarch, memaddr));
175 default:
176 internal_error ("unhandled target_xfer_status: %s (%s)",
178 plongest (err));
179 }
180}
181
182/* Report a memory error by throwing a suitable exception. */
183
184void
185memory_error (enum target_xfer_status err, CORE_ADDR memaddr)
186{
187 enum errors exception = GDB_NO_ERROR;
188
189 /* Build error string. */
190 std::string str = memory_error_message (err, target_gdbarch (), memaddr);
191
192 /* Choose the right error to throw. */
193 switch (err)
194 {
195 case TARGET_XFER_E_IO:
196 exception = MEMORY_ERROR;
197 break;
199 exception = NOT_AVAILABLE_ERROR;
200 break;
201 }
202
203 /* Throw it. */
204 throw_error (exception, ("%s"), str.c_str ());
205}
206
207/* Helper function. */
208
209static void
210read_memory_object (enum target_object object, CORE_ADDR memaddr,
211 gdb_byte *myaddr, ssize_t len)
212{
213 ULONGEST xfered = 0;
214
215 while (xfered < len)
216 {
218 ULONGEST xfered_len;
219
220 status = target_xfer_partial (current_inferior ()->top_target (), object,
221 NULL, myaddr + xfered, NULL,
222 memaddr + xfered, len - xfered,
223 &xfered_len);
224
225 if (status != TARGET_XFER_OK)
227 memaddr + xfered);
228
229 xfered += xfered_len;
230 QUIT;
231 }
232}
233
234/* Same as target_read_memory, but report an error if can't read. */
235
236void
237read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
238{
239 read_memory_object (TARGET_OBJECT_MEMORY, memaddr, myaddr, len);
240}
241
242/* Same as target_read_stack, but report an error if can't read. */
243
244void
245read_stack (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
246{
247 read_memory_object (TARGET_OBJECT_STACK_MEMORY, memaddr, myaddr, len);
248}
249
250/* Same as target_read_code, but report an error if can't read. */
251
252void
253read_code (CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
254{
255 read_memory_object (TARGET_OBJECT_CODE_MEMORY, memaddr, myaddr, len);
256}
257
258/* Read memory at MEMADDR of length LEN and put the contents in
259 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
260 if successful. */
261
262int
263safe_read_memory_integer (CORE_ADDR memaddr, int len,
264 enum bfd_endian byte_order,
265 LONGEST *return_value)
266{
267 gdb_byte buf[sizeof (LONGEST)];
268
269 if (target_read_memory (memaddr, buf, len))
270 return 0;
271
272 *return_value = extract_signed_integer (buf, len, byte_order);
273 return 1;
274}
275
276/* Read memory at MEMADDR of length LEN and put the contents in
277 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
278 if successful. */
279
280int
281safe_read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
282 enum bfd_endian byte_order,
283 ULONGEST *return_value)
284{
285 gdb_byte buf[sizeof (ULONGEST)];
286
287 if (target_read_memory (memaddr, buf, len))
288 return 0;
289
290 *return_value = extract_unsigned_integer (buf, len, byte_order);
291 return 1;
292}
293
294LONGEST
295read_memory_integer (CORE_ADDR memaddr, int len,
296 enum bfd_endian byte_order)
297{
298 gdb_byte buf[sizeof (LONGEST)];
299
300 read_memory (memaddr, buf, len);
301 return extract_signed_integer (buf, len, byte_order);
302}
303
304ULONGEST
305read_memory_unsigned_integer (CORE_ADDR memaddr, int len,
306 enum bfd_endian byte_order)
307{
308 gdb_byte buf[sizeof (ULONGEST)];
309
310 read_memory (memaddr, buf, len);
311 return extract_unsigned_integer (buf, len, byte_order);
312}
313
314LONGEST
315read_code_integer (CORE_ADDR memaddr, int len,
316 enum bfd_endian byte_order)
317{
318 gdb_byte buf[sizeof (LONGEST)];
319
320 read_code (memaddr, buf, len);
321 return extract_signed_integer (buf, len, byte_order);
322}
323
324ULONGEST
325read_code_unsigned_integer (CORE_ADDR memaddr, int len,
326 enum bfd_endian byte_order)
327{
328 gdb_byte buf[sizeof (ULONGEST)];
329
330 read_code (memaddr, buf, len);
331 return extract_unsigned_integer (buf, len, byte_order);
332}
333
334CORE_ADDR
335read_memory_typed_address (CORE_ADDR addr, struct type *type)
336{
337 gdb_byte *buf = (gdb_byte *) alloca (type->length ());
338
339 read_memory (addr, buf, type->length ());
340 return extract_typed_address (buf, type);
341}
342
343/* See gdbcore.h. */
344
345void
346write_memory (CORE_ADDR memaddr,
347 const bfd_byte *myaddr, ssize_t len)
348{
349 int status;
350
351 status = target_write_memory (memaddr, myaddr, len);
352 if (status != 0)
354}
355
356/* Same as write_memory, but notify 'memory_changed' observers. */
357
358void
359write_memory_with_notification (CORE_ADDR memaddr, const bfd_byte *myaddr,
360 ssize_t len)
361{
362 write_memory (memaddr, myaddr, len);
363 gdb::observers::memory_changed.notify (current_inferior (), memaddr, len, myaddr);
364}
365
366/* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
367 integer. */
368void
369write_memory_unsigned_integer (CORE_ADDR addr, int len,
370 enum bfd_endian byte_order,
371 ULONGEST value)
372{
373 gdb_byte *buf = (gdb_byte *) alloca (len);
374
375 store_unsigned_integer (buf, len, byte_order, value);
376 write_memory (addr, buf, len);
377}
378
379/* Store VALUE at ADDR in the inferior as a LEN-byte signed
380 integer. */
381void
382write_memory_signed_integer (CORE_ADDR addr, int len,
383 enum bfd_endian byte_order,
384 LONGEST value)
385{
386 gdb_byte *buf = (gdb_byte *) alloca (len);
387
388 store_signed_integer (buf, len, byte_order, value);
389 write_memory (addr, buf, len);
390}
391
392/* The current default bfd target. Points to storage allocated for
393 gnutarget_string. */
394const char *gnutarget;
395
396/* Same thing, except it is "auto" not NULL for the default case. */
397static std::string gnutarget_string;
398static void
399show_gnutarget_string (struct ui_file *file, int from_tty,
400 struct cmd_list_element *c,
401 const char *value)
402{
403 gdb_printf (file,
404 _("The current BFD target is \"%s\".\n"), value);
405}
406
407static void
408set_gnutarget_command (const char *ignore, int from_tty,
409 struct cmd_list_element *c)
410{
411 const char *gend = gnutarget_string.c_str () + gnutarget_string.size ();
412 gend = remove_trailing_whitespace (gnutarget_string.c_str (), gend);
414 = gnutarget_string.substr (0, gend - gnutarget_string.data ());
415
416 if (gnutarget_string == "auto")
417 gnutarget = NULL;
418 else
419 gnutarget = gnutarget_string.c_str ();
420}
421
422/* A completion function for "set gnutarget". */
423
424static void
426 completion_tracker &tracker,
427 const char *text, const char *word)
428{
429 static const char **bfd_targets;
430
431 if (bfd_targets == NULL)
432 {
433 int last;
434
435 bfd_targets = bfd_target_list ();
436 for (last = 0; bfd_targets[last] != NULL; ++last)
437 ;
438
439 bfd_targets = XRESIZEVEC (const char *, bfd_targets, last + 2);
440 bfd_targets[last] = "auto";
441 bfd_targets[last + 1] = NULL;
442 }
443
444 complete_on_enum (tracker, bfd_targets, text, word);
445}
446
447/* Set the gnutarget. */
448void
449set_gnutarget (const char *newtarget)
450{
451 gnutarget_string = newtarget;
452 set_gnutarget_command (NULL, 0, NULL);
453}
454
455void _initialize_core ();
456void
458{
459 cmd_list_element *core_file_cmd
460 = add_cmd ("core-file", class_files, core_file_command, _("\
461Use FILE as core dump for examining memory and registers.\n\
462Usage: core-file FILE\n\
463No arg means have no core file. This command has been superseded by the\n\
464`target core' and `detach' commands."), &cmdlist);
465 set_cmd_completer (core_file_cmd, filename_completer);
466
467
468 set_show_commands set_show_gnutarget
470 &gnutarget_string, _("\
471Set the current BFD target."), _("\
472Show the current BFD target."), _("\
473Use `set gnutarget auto' to specify automatic detection."),
476 &setlist, &showlist);
477 set_cmd_completer (set_show_gnutarget.set, complete_set_gnutarget);
478
479 add_alias_cmd ("g", set_show_gnutarget.set, class_files, 1, &setlist);
480
481 if (getenv ("GNUTARGET"))
482 set_gnutarget (getenv ("GNUTARGET"));
483 else
484 set_gnutarget ("auto");
485}
void * xrealloc(void *ptr, size_t size)
Definition: alloc.c:65
struct gdbarch * target_gdbarch(void)
Definition: arch-utils.c:1453
struct cmd_list_element * showlist
Definition: cli-cmds.c:125
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:85
struct cmd_list_element * setlist
Definition: cli-cmds.c:117
struct cmd_list_element * add_alias_cmd(const char *name, cmd_list_element *target, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:294
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:233
void set_cmd_completer(struct cmd_list_element *cmd, completer_ftype *completer)
Definition: cli-decode.c:117
set_show_commands add_setshow_string_noescape_cmd(const char *name, enum command_class theclass, std::string *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_func_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:883
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
Definition: cli-decode.c:2519
const char * remove_trailing_whitespace(const char *start, const char *s)
Definition: cli-utils.c:372
@ class_files
Definition: command.h:57
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:204
void validate_files(void)
Definition: corefile.c:133
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:346
CORE_ADDR read_memory_typed_address(CORE_ADDR addr, struct type *type)
Definition: corefile.c:335
static void complete_set_gnutarget(struct cmd_list_element *cmd, completion_tracker &tracker, const char *text, const char *word)
Definition: corefile.c:425
void read_stack(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:245
static void show_gnutarget_string(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: corefile.c:399
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:305
void reopen_exec_file(void)
Definition: corefile.c:105
static void set_gnutarget_command(const char *ignore, int from_tty, struct cmd_list_element *c)
Definition: corefile.c:408
static void read_memory_object(enum target_object object, CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:210
static void call_extra_exec_file_hooks(const char *filename)
Definition: corefile.c:60
void write_memory_unsigned_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, ULONGEST value)
Definition: corefile.c:369
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:237
void specify_exec_file_hook(void(*hook)(const char *))
Definition: corefile.c:72
const char * get_exec_file(int err)
Definition: corefile.c:149
int safe_read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, LONGEST *return_value)
Definition: corefile.c:263
LONGEST read_memory_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:295
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:359
int safe_read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order, ULONGEST *return_value)
Definition: corefile.c:281
ULONGEST read_code_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:325
hook_type deprecated_exec_file_display_hook
Definition: corefile.c:48
void read_code(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:253
void write_memory_signed_integer(CORE_ADDR addr, int len, enum bfd_endian byte_order, LONGEST value)
Definition: corefile.c:382
static std::string gnutarget_string
Definition: corefile.c:397
void set_gnutarget(const char *newtarget)
Definition: corefile.c:449
static int exec_file_hook_count
Definition: corefile.c:51
const char * gnutarget
Definition: corefile.c:394
LONGEST read_code_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:315
void memory_error(enum target_xfer_status err, CORE_ADDR memaddr)
Definition: corefile.c:185
static hook_type * exec_file_extra_hooks
Definition: corefile.c:49
void _initialize_core()
Definition: corefile.c:457
void(* hook_type)(const char *)
Definition: corefile.c:46
std::string memory_error_message(enum target_xfer_status err, struct gdbarch *gdbarch, CORE_ADDR memaddr)
Definition: corefile.c:162
void core_file_command(const char *filename, int from_tty)
Definition: corelow.c:406
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:554
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:561
CORE_ADDR extract_typed_address(const gdb_byte *buf, struct type *type)
Definition: findvar.c:153
static LONGEST extract_signed_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition: defs.h:511
static ULONGEST extract_unsigned_integer(gdb::array_view< const gdb_byte > buf, enum bfd_endian byte_order)
Definition: defs.h:526
#define QUIT
Definition: defs.h:186
void exec_file_attach(const char *filename, int from_tty)
Definition: exec.c:365
#define core_bfd
Definition: gdbcore.h:130
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t err
Definition: gnu-nat.c:1790
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1791
struct inferior * current_inferior(void)
Definition: inferior.c:54
observable< struct inferior *, CORE_ADDR, ssize_t, const bfd_byte * > memory_changed
struct program_space * current_program_space
Definition: progspace.c:39
bfd * exec_bfd() const
Definition: progspace.h:264
gdb::unique_xmalloc_ptr< char > exec_filename
Definition: progspace.h:321
long ebfd_mtime
Definition: progspace.h:317
cmd_list_element * set
Definition: command.h:406
Definition: gdbtypes.h:922
ULONGEST length() const
Definition: gdbtypes.h:954
Definition: value.c:181
const char * target_xfer_status_to_string(enum target_xfer_status status)
Definition: target.c:1356
int target_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, ssize_t len)
Definition: target.c:1847
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1771
target_xfer_partial_ftype target_xfer_partial
target_xfer_status
Definition: target.h:214
@ TARGET_XFER_E_IO
Definition: target.h:227
@ TARGET_XFER_EOF
Definition: target.h:219
@ TARGET_XFER_OK
Definition: target.h:216
@ TARGET_XFER_UNAVAILABLE
Definition: target.h:222
target_object
Definition: target.h:138
@ TARGET_OBJECT_STACK_MEMORY
Definition: target.h:150
@ TARGET_OBJECT_MEMORY
Definition: target.h:142
@ TARGET_OBJECT_CODE_MEMORY
Definition: target.h:153
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:3114
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition: utils.c:1865