1 /* Core dump and executable file functions above target vector, for GDB.
3 Copyright (C) 1986-2020 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
32 #include "completer.h"
33 #include "observable.h"
34 #include "cli/cli-utils.h"
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. */
46 typedef void (*hook_type
) (const char *);
48 hook_type deprecated_exec_file_display_hook
; /* The original hook. */
49 static hook_type
*exec_file_extra_hooks
; /* Array of additional
51 static int exec_file_hook_count
= 0; /* Size of array. */
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
60 call_extra_exec_file_hooks (const char *filename
)
64 for (i
= 0; i
< exec_file_hook_count
; i
++)
65 (*exec_file_extra_hooks
[i
]) (filename
);
68 /* Call this to specify the hook for exec_file_command to call back.
69 This is called from the x-window display code. */
72 specify_exec_file_hook (void (*hook
) (const char *))
76 if (deprecated_exec_file_display_hook
!= NULL
)
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)
82 /* If this is the first extra hook, initialize the hook
84 exec_file_extra_hooks
= XNEW (hook_type
);
85 exec_file_extra_hooks
[0] = deprecated_exec_file_display_hook
;
86 deprecated_exec_file_display_hook
= call_extra_exec_file_hooks
;
87 exec_file_hook_count
= 1;
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. */
93 exec_file_hook_count
++;
94 new_array
= (hook_type
*)
95 xrealloc (exec_file_extra_hooks
,
96 exec_file_hook_count
* sizeof (hook_type
));
97 exec_file_extra_hooks
= new_array
;
98 exec_file_extra_hooks
[exec_file_hook_count
- 1] = hook
;
101 deprecated_exec_file_display_hook
= hook
;
105 reopen_exec_file (void)
110 /* Don't do anything if there isn't an exec file. */
111 if (exec_bfd
== NULL
)
114 /* If the timestamp of the exec file has changed, reopen it. */
115 std::string filename
= bfd_get_filename (exec_bfd
);
116 res
= stat (filename
.c_str (), &st
);
118 if (res
== 0 && exec_bfd_mtime
&& exec_bfd_mtime
!= st
.st_mtime
)
119 exec_file_attach (filename
.c_str (), 0);
121 /* If we accessed the file since last opening it, close it now;
122 this stops GDB from holding the executable open after it
124 bfd_cache_close_all ();
127 /* If we have both a core file and an exec file,
128 print a warning if they don't go together. */
131 validate_files (void)
133 if (exec_bfd
&& core_bfd
)
135 if (!core_file_matches_executable_p (core_bfd
, exec_bfd
))
136 warning (_("core file may not match specified executable file."));
137 else if (bfd_get_mtime (exec_bfd
) > bfd_get_mtime (core_bfd
))
138 warning (_("exec file is newer than core file."));
142 /* See gdbsupport/common-inferior.h. */
145 get_exec_file (int err
)
148 return exec_filename
;
152 error (_("No executable file specified.\n\
153 Use the \"file\" or \"exec-file\" command."));
158 memory_error_message (enum target_xfer_status err
,
159 struct gdbarch
*gdbarch
, CORE_ADDR memaddr
)
163 case TARGET_XFER_E_IO
:
164 /* Actually, address between memaddr and memaddr + len was out of
166 return string_printf (_("Cannot access memory at address %s"),
167 paddress (gdbarch
, memaddr
));
168 case TARGET_XFER_UNAVAILABLE
:
169 return string_printf (_("Memory at address %s unavailable."),
170 paddress (gdbarch
, memaddr
));
172 internal_error (__FILE__
, __LINE__
,
173 "unhandled target_xfer_status: %s (%s)",
174 target_xfer_status_to_string (err
),
179 /* Report a memory error by throwing a suitable exception. */
182 memory_error (enum target_xfer_status err
, CORE_ADDR memaddr
)
184 enum errors exception
= GDB_NO_ERROR
;
186 /* Build error string. */
187 std::string str
= memory_error_message (err
, target_gdbarch (), memaddr
);
189 /* Choose the right error to throw. */
192 case TARGET_XFER_E_IO
:
193 exception
= MEMORY_ERROR
;
195 case TARGET_XFER_UNAVAILABLE
:
196 exception
= NOT_AVAILABLE_ERROR
;
201 throw_error (exception
, ("%s"), str
.c_str ());
204 /* Helper function. */
207 read_memory_object (enum target_object object
, CORE_ADDR memaddr
,
208 gdb_byte
*myaddr
, ssize_t len
)
214 enum target_xfer_status status
;
217 status
= target_xfer_partial (current_top_target (), object
, NULL
,
218 myaddr
+ xfered
, NULL
,
219 memaddr
+ xfered
, len
- xfered
,
222 if (status
!= TARGET_XFER_OK
)
223 memory_error (status
== TARGET_XFER_EOF
? TARGET_XFER_E_IO
: status
,
226 xfered
+= xfered_len
;
231 /* Same as target_read_memory, but report an error if can't read. */
234 read_memory (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
236 read_memory_object (TARGET_OBJECT_MEMORY
, memaddr
, myaddr
, len
);
239 /* Same as target_read_stack, but report an error if can't read. */
242 read_stack (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
244 read_memory_object (TARGET_OBJECT_STACK_MEMORY
, memaddr
, myaddr
, len
);
247 /* Same as target_read_code, but report an error if can't read. */
250 read_code (CORE_ADDR memaddr
, gdb_byte
*myaddr
, ssize_t len
)
252 read_memory_object (TARGET_OBJECT_CODE_MEMORY
, memaddr
, myaddr
, len
);
255 /* Read memory at MEMADDR of length LEN and put the contents in
256 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
260 safe_read_memory_integer (CORE_ADDR memaddr
, int len
,
261 enum bfd_endian byte_order
,
262 LONGEST
*return_value
)
264 gdb_byte buf
[sizeof (LONGEST
)];
266 if (target_read_memory (memaddr
, buf
, len
))
269 *return_value
= extract_signed_integer (buf
, len
, byte_order
);
273 /* Read memory at MEMADDR of length LEN and put the contents in
274 RETURN_VALUE. Return 0 if MEMADDR couldn't be read and non-zero
278 safe_read_memory_unsigned_integer (CORE_ADDR memaddr
, int len
,
279 enum bfd_endian byte_order
,
280 ULONGEST
*return_value
)
282 gdb_byte buf
[sizeof (ULONGEST
)];
284 if (target_read_memory (memaddr
, buf
, len
))
287 *return_value
= extract_unsigned_integer (buf
, len
, byte_order
);
292 read_memory_integer (CORE_ADDR memaddr
, int len
,
293 enum bfd_endian byte_order
)
295 gdb_byte buf
[sizeof (LONGEST
)];
297 read_memory (memaddr
, buf
, len
);
298 return extract_signed_integer (buf
, len
, byte_order
);
302 read_memory_unsigned_integer (CORE_ADDR memaddr
, int len
,
303 enum bfd_endian byte_order
)
305 gdb_byte buf
[sizeof (ULONGEST
)];
307 read_memory (memaddr
, buf
, len
);
308 return extract_unsigned_integer (buf
, len
, byte_order
);
312 read_code_integer (CORE_ADDR memaddr
, int len
,
313 enum bfd_endian byte_order
)
315 gdb_byte buf
[sizeof (LONGEST
)];
317 read_code (memaddr
, buf
, len
);
318 return extract_signed_integer (buf
, len
, byte_order
);
322 read_code_unsigned_integer (CORE_ADDR memaddr
, int len
,
323 enum bfd_endian byte_order
)
325 gdb_byte buf
[sizeof (ULONGEST
)];
327 read_code (memaddr
, buf
, len
);
328 return extract_unsigned_integer (buf
, len
, byte_order
);
332 read_memory_typed_address (CORE_ADDR addr
, struct type
*type
)
334 gdb_byte
*buf
= (gdb_byte
*) alloca (TYPE_LENGTH (type
));
336 read_memory (addr
, buf
, TYPE_LENGTH (type
));
337 return extract_typed_address (buf
, type
);
343 write_memory (CORE_ADDR memaddr
,
344 const bfd_byte
*myaddr
, ssize_t len
)
348 status
= target_write_memory (memaddr
, myaddr
, len
);
350 memory_error (TARGET_XFER_E_IO
, memaddr
);
353 /* Same as write_memory, but notify 'memory_changed' observers. */
356 write_memory_with_notification (CORE_ADDR memaddr
, const bfd_byte
*myaddr
,
359 write_memory (memaddr
, myaddr
, len
);
360 gdb::observers::memory_changed
.notify (current_inferior (), memaddr
, len
, myaddr
);
363 /* Store VALUE at ADDR in the inferior as a LEN-byte unsigned
366 write_memory_unsigned_integer (CORE_ADDR addr
, int len
,
367 enum bfd_endian byte_order
,
370 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
372 store_unsigned_integer (buf
, len
, byte_order
, value
);
373 write_memory (addr
, buf
, len
);
376 /* Store VALUE at ADDR in the inferior as a LEN-byte signed
379 write_memory_signed_integer (CORE_ADDR addr
, int len
,
380 enum bfd_endian byte_order
,
383 gdb_byte
*buf
= (gdb_byte
*) alloca (len
);
385 store_signed_integer (buf
, len
, byte_order
, value
);
386 write_memory (addr
, buf
, len
);
389 /* The current default bfd target. Points to storage allocated for
391 const char *gnutarget
;
393 /* Same thing, except it is "auto" not NULL for the default case. */
394 static char *gnutarget_string
;
396 show_gnutarget_string (struct ui_file
*file
, int from_tty
,
397 struct cmd_list_element
*c
,
400 fprintf_filtered (file
,
401 _("The current BFD target is \"%s\".\n"), value
);
405 set_gnutarget_command (const char *ignore
, int from_tty
,
406 struct cmd_list_element
*c
)
408 char *gend
= gnutarget_string
+ strlen (gnutarget_string
);
410 gend
= remove_trailing_whitespace (gnutarget_string
, gend
);
413 if (strcmp (gnutarget_string
, "auto") == 0)
416 gnutarget
= gnutarget_string
;
419 /* A completion function for "set gnutarget". */
422 complete_set_gnutarget (struct cmd_list_element
*cmd
,
423 completion_tracker
&tracker
,
424 const char *text
, const char *word
)
426 static const char **bfd_targets
;
428 if (bfd_targets
== NULL
)
432 bfd_targets
= bfd_target_list ();
433 for (last
= 0; bfd_targets
[last
] != NULL
; ++last
)
436 bfd_targets
= XRESIZEVEC (const char *, bfd_targets
, last
+ 2);
437 bfd_targets
[last
] = "auto";
438 bfd_targets
[last
+ 1] = NULL
;
441 complete_on_enum (tracker
, bfd_targets
, text
, word
);
444 /* Set the gnutarget. */
446 set_gnutarget (const char *newtarget
)
448 xfree (gnutarget_string
);
449 gnutarget_string
= xstrdup (newtarget
);
450 set_gnutarget_command (NULL
, 0, NULL
);
453 void _initialize_core ();
457 struct cmd_list_element
*c
;
459 c
= add_cmd ("core-file", class_files
, core_file_command
, _("\
460 Use FILE as core dump for examining memory and registers.\n\
461 Usage: core-file FILE\n\
462 No arg means have no core file. This command has been superseded by the\n\
463 `target core' and `detach' commands."), &cmdlist
);
464 set_cmd_completer (c
, filename_completer
);
467 c
= add_setshow_string_noescape_cmd ("gnutarget", class_files
,
468 &gnutarget_string
, _("\
469 Set the current BFD target."), _("\
470 Show the current BFD target."), _("\
471 Use `set gnutarget auto' to specify automatic detection."),
472 set_gnutarget_command
,
473 show_gnutarget_string
,
474 &setlist
, &showlist
);
475 set_cmd_completer (c
, complete_set_gnutarget
);
477 add_alias_cmd ("g", "gnutarget", class_files
, 1, &setlist
);
479 if (getenv ("GNUTARGET"))
480 set_gnutarget (getenv ("GNUTARGET"));
482 set_gnutarget ("auto");