/* Work with executable files, for GDB.
- Copyright (C) 1988-2016 Free Software Foundation, Inc.
+ Copyright (C) 1988-2017 Free Software Foundation, Inc.
This file is part of GDB.
#include "solist.h"
#include <algorithm>
-void (*deprecated_file_changed_hook) (char *);
+void (*deprecated_file_changed_hook) (const char *);
/* Prototypes for local functions */
-static void file_command (char *, int);
-
-static void set_section_command (char *, int);
-
static void exec_files_info (struct target_ops *);
static void init_exec_ops (void);
-void _initialize_exec (void);
-
/* The target vector for executable files. */
static struct target_ops exec_ops;
exec_close_1 (struct target_ops *self)
{
struct program_space *ss;
- struct cleanup *old_chain;
+ scoped_restore_current_program_space restore_pspace;
- old_chain = save_current_program_space ();
ALL_PSPACES (ss)
- {
- set_current_program_space (ss);
- clear_section_table (current_target_sections);
- exec_close ();
- }
-
- do_cleanups (old_chain);
+ {
+ set_current_program_space (ss);
+ clear_section_table (current_target_sections);
+ exec_close ();
+ }
}
void
printf_unfiltered (_("No executable file now.\n"));
}
-/* Returns non-zero if exceptions E1 and E2 are equal. Returns zero
- otherwise. */
-
-static int
-exception_print_same (struct gdb_exception e1, struct gdb_exception e2)
-{
- const char *msg1 = e1.message;
- const char *msg2 = e2.message;
-
- if (msg1 == NULL)
- msg1 = "";
- if (msg2 == NULL)
- msg2 = "";
-
- return (e1.reason == e2.reason
- && e1.error == e2.error
- && strcmp (e1.message, e2.message) == 0);
-}
-
-/* See gdbcore.h. */
+/* See exec.h. */
void
-exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty)
+try_open_exec_file (const char *exec_file_host, struct inferior *inf,
+ symfile_add_flags add_flags)
{
- char *exec_file, *full_exec_path = NULL;
struct cleanup *old_chain;
struct gdb_exception prev_err = exception_none;
- /* Do nothing if we already have an executable filename. */
- exec_file = (char *) get_exec_file (0);
- if (exec_file != NULL)
- return;
-
- /* Try to determine a filename from the process itself. */
- exec_file = target_pid_to_exec_file (pid);
- if (exec_file == NULL)
- {
- warning (_("No executable has been specified and target does not "
- "support\n"
- "determining executable automatically. "
- "Try using the \"file\" command."));
- return;
- }
-
- /* If gdb_sysroot is not empty and the discovered filename
- is absolute then prefix the filename with gdb_sysroot. */
- if (*gdb_sysroot != '\0' && IS_ABSOLUTE_PATH (exec_file))
- {
- full_exec_path = exec_file_find (exec_file, NULL);
- if (full_exec_path == NULL)
- return;
- }
- else
- {
- /* It's possible we don't have a full path, but rather just a
- filename. Some targets, such as HP-UX, don't provide the
- full path, sigh.
-
- Attempt to qualify the filename against the source path.
- (If that fails, we'll just fall back on the original
- filename. Not much more we can do...) */
- if (!source_full_path_of (exec_file, &full_exec_path))
- full_exec_path = xstrdup (exec_file);
- }
-
- old_chain = make_cleanup (xfree, full_exec_path);
- make_cleanup (free_current_contents, &prev_err.message);
+ old_chain = make_cleanup (free_current_contents, &prev_err.message);
/* exec_file_attach and symbol_file_add_main may throw an error if the file
cannot be opened either locally or remotely.
errors/exceptions in the following code. */
TRY
{
- exec_file_attach (full_exec_path, from_tty);
+ /* We must do this step even if exec_file_host is NULL, so that
+ exec_file_attach will clear state. */
+ exec_file_attach (exec_file_host, add_flags & SYMFILE_VERBOSE);
}
CATCH (err, RETURN_MASK_ERROR)
{
prev_err = err;
/* Save message so it doesn't get trashed by the catch below. */
- prev_err.message = xstrdup (err.message);
+ if (err.message != NULL)
+ prev_err.message = xstrdup (err.message);
}
END_CATCH
- TRY
+ if (exec_file_host != NULL)
{
- if (defer_bp_reset)
- current_inferior ()->symfile_flags |= SYMFILE_DEFER_BP_RESET;
- symbol_file_add_main (full_exec_path, from_tty);
+ TRY
+ {
+ symbol_file_add_main (exec_file_host, add_flags);
+ }
+ CATCH (err, RETURN_MASK_ERROR)
+ {
+ if (!exception_print_same (prev_err, err))
+ warning ("%s", err.message);
+ }
+ END_CATCH
}
- CATCH (err, RETURN_MASK_ERROR)
+
+ do_cleanups (old_chain);
+}
+
+/* See gdbcore.h. */
+
+void
+exec_file_locate_attach (int pid, int defer_bp_reset, int from_tty)
+{
+ char *exec_file_target, *exec_file_host;
+ struct cleanup *old_chain;
+ symfile_add_flags add_flags = 0;
+
+ /* Do nothing if we already have an executable filename. */
+ if (get_exec_file (0) != NULL)
+ return;
+
+ /* Try to determine a filename from the process itself. */
+ exec_file_target = target_pid_to_exec_file (pid);
+ if (exec_file_target == NULL)
{
- if (!exception_print_same (prev_err, err))
- warning ("%s", err.message);
+ warning (_("No executable has been specified and target does not "
+ "support\n"
+ "determining executable automatically. "
+ "Try using the \"file\" command."));
+ return;
}
- END_CATCH
- current_inferior ()->symfile_flags &= ~SYMFILE_DEFER_BP_RESET;
+ exec_file_host = exec_file_find (exec_file_target, NULL);
+ old_chain = make_cleanup (xfree, exec_file_host);
+
+ if (defer_bp_reset)
+ add_flags |= SYMFILE_DEFER_BP_RESET;
+
+ if (from_tty)
+ add_flags |= SYMFILE_VERBOSE;
+
+ /* Attempt to open the exec file. */
+ try_open_exec_file (exec_file_host, current_inferior (), add_flags);
do_cleanups (old_chain);
}
void
exec_file_attach (const char *filename, int from_tty)
{
- struct cleanup *cleanups;
-
/* First, acquire a reference to the current exec_bfd. We release
this at the end of the function; but acquiring it now lets the
BFD cache return it if this call refers to the same file. */
- gdb_bfd_ref (exec_bfd);
- cleanups = make_cleanup_bfd_unref (exec_bfd);
+ gdb_bfd_ref_ptr exec_bfd_holder = new_bfd_ref (exec_bfd);
/* Remove any previous exec file. */
exec_close ();
else
{
int load_via_target = 0;
- char *scratch_pathname, *canonical_pathname;
+ const char *scratch_pathname, *canonical_pathname;
int scratch_chan;
struct target_section *sections = NULL, *sections_end = NULL;
char **matching;
load_via_target = 1;
}
+ gdb::unique_xmalloc_ptr<char> canonical_storage, scratch_storage;
if (load_via_target)
{
/* gdb_bfd_fopen does not support "target:" filenames. */
"not supported for %s sysroots"),
TARGET_SYSROOT_PREFIX);
- scratch_pathname = xstrdup (filename);
- make_cleanup (xfree, scratch_pathname);
-
+ scratch_pathname = filename;
scratch_chan = -1;
-
canonical_pathname = scratch_pathname;
}
else
{
+ char *temp_pathname;
+
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
filename, write_files ?
O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
- &scratch_pathname);
+ &temp_pathname);
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
if (scratch_chan < 0)
{
exename, write_files ?
O_RDWR | O_BINARY
: O_RDONLY | O_BINARY,
- &scratch_pathname);
+ &temp_pathname);
}
#endif
if (scratch_chan < 0)
perror_with_name (filename);
- make_cleanup (xfree, scratch_pathname);
+ scratch_storage.reset (temp_pathname);
+ scratch_pathname = temp_pathname;
/* gdb_bfd_open (and its variants) prefers canonicalized
pathname for better BFD caching. */
- canonical_pathname = gdb_realpath (scratch_pathname);
- make_cleanup (xfree, canonical_pathname);
+ canonical_storage = gdb_realpath (scratch_pathname);
+ canonical_pathname = canonical_storage.get ();
}
+ gdb_bfd_ref_ptr temp;
if (write_files && !load_via_target)
- exec_bfd = gdb_bfd_fopen (canonical_pathname, gnutarget,
- FOPEN_RUB, scratch_chan);
+ temp = gdb_bfd_fopen (canonical_pathname, gnutarget,
+ FOPEN_RUB, scratch_chan);
else
- exec_bfd = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
+ temp = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
+ exec_bfd = temp.release ();
if (!exec_bfd)
{
if (load_via_target)
exec_filename = xstrdup (bfd_get_filename (exec_bfd));
else
- exec_filename = gdb_realpath_keepfile (scratch_pathname);
+ exec_filename = gdb_realpath_keepfile (scratch_pathname).release ();
if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
{
(*deprecated_exec_file_display_hook) (filename);
}
- do_cleanups (cleanups);
-
bfd_cache_close_all ();
observer_notify_executable_changed ();
}
If ARGS is NULL, we just want to close the exec file. */
static void
-exec_file_command (char *args, int from_tty)
+exec_file_command (const char *args, int from_tty)
{
- char **argv;
char *filename;
if (from_tty && target_has_execution
if (args)
{
- struct cleanup *cleanups;
-
/* Scan through the args and pick up the first non option arg
as the filename. */
- argv = gdb_buildargv (args);
- cleanups = make_cleanup_freeargv (argv);
+ gdb_argv built_argv (args);
+ char **argv = built_argv.get ();
for (; (*argv != NULL) && (**argv == '-'); argv++)
{;
if (*argv == NULL)
error (_("No executable file name was specified"));
- filename = tilde_expand (*argv);
- make_cleanup (xfree, filename);
- exec_file_attach (filename, from_tty);
-
- do_cleanups (cleanups);
+ gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv));
+ exec_file_attach (filename.get (), from_tty);
}
else
exec_file_attach (NULL, from_tty);
command was added? */
static void
-file_command (char *arg, int from_tty)
+file_command (const char *arg, int from_tty)
{
/* FIXME, if we lose on reading the symbol file, we should revert
the exec file, but that's rough. */
return TARGET_XFER_E_IO;
}
-/* Appends all read-only memory ranges found in the target section
+/* Return all read-only memory ranges found in the target section
table defined by SECTIONS and SECTIONS_END, starting at (and
- intersected with) MEMADDR for LEN bytes. Returns the augmented
- VEC. */
+ intersected with) MEMADDR for LEN bytes. */
-static VEC(mem_range_s) *
-section_table_available_memory (VEC(mem_range_s) *memory,
- CORE_ADDR memaddr, ULONGEST len,
+static std::vector<mem_range>
+section_table_available_memory (CORE_ADDR memaddr, ULONGEST len,
struct target_section *sections,
struct target_section *sections_end)
{
- struct target_section *p;
+ std::vector<mem_range> memory;
- for (p = sections; p < sections_end; p++)
+ for (target_section *p = sections; p < sections_end; p++)
{
if ((bfd_get_section_flags (p->the_bfd_section->owner,
p->the_bfd_section)
if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
{
ULONGEST lo1, hi1, lo2, hi2;
- struct mem_range *r;
lo1 = memaddr;
hi1 = memaddr + len;
lo2 = p->addr;
hi2 = p->endaddr;
- r = VEC_safe_push (mem_range_s, memory, NULL);
+ CORE_ADDR start = std::max (lo1, lo2);
+ int length = std::min (hi1, hi2) - start;
- r->start = std::max (lo1, lo2);
- r->length = std::min (hi1, hi2) - r->start;
+ memory.emplace_back (start, length);
}
}
section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
ULONGEST len, ULONGEST *xfered_len)
{
- VEC(mem_range_s) *available_memory = NULL;
- struct target_section_table *table;
- struct cleanup *old_chain;
- mem_range_s *r;
- int i;
-
- table = target_get_section_table (&exec_ops);
- available_memory = section_table_available_memory (available_memory,
- offset, len,
- table->sections,
- table->sections_end);
+ target_section_table *table = target_get_section_table (&exec_ops);
+ std::vector<mem_range> available_memory
+ = section_table_available_memory (offset, len,
+ table->sections, table->sections_end);
- old_chain = make_cleanup (VEC_cleanup(mem_range_s),
- &available_memory);
+ normalize_mem_ranges (&available_memory);
- normalize_mem_ranges (available_memory);
-
- for (i = 0;
- VEC_iterate (mem_range_s, available_memory, i, r);
- i++)
+ for (const mem_range &r : available_memory)
{
- if (mem_ranges_overlap (r->start, r->length, offset, len))
+ if (mem_ranges_overlap (r.start, r.length, offset, len))
{
CORE_ADDR end;
enum target_xfer_status status;
/* Get the intersection window. */
- end = std::min<CORE_ADDR> (offset + len, r->start + r->length);
+ end = std::min<CORE_ADDR> (offset + len, r.start + r.length);
gdb_assert (end - offset <= len);
- if (offset >= r->start)
+ if (offset >= r.start)
status = exec_read_partial_read_only (readbuf, offset,
end - offset,
xfered_len);
else
{
- *xfered_len = r->start - offset;
+ *xfered_len = r.start - offset;
status = TARGET_XFER_UNAVAILABLE;
}
- do_cleanups (old_chain);
return status;
}
}
- do_cleanups (old_chain);
*xfered_len = len;
return TARGET_XFER_UNAVAILABLE;
}
static void
-set_section_command (char *args, int from_tty)
+set_section_command (const char *args, int from_tty)
{
struct target_section *p;
- char *secname;
+ const char *secname;
unsigned seclen;
unsigned long secaddr;
char secprint[100];
projects / deliverable / binutils-gdb.git / blobdiff