/* Work with executable files, for GDB.
- Copyright (C) 1988-2017 Free Software Foundation, Inc.
+ Copyright (C) 1988-2018 Free Software Foundation, Inc.
This file is part of GDB.
#include "completer.h"
#include "value.h"
#include "exec.h"
-#include "observer.h"
+#include "observable.h"
#include "arch-utils.h"
#include "gdbthread.h"
#include "progspace.h"
#include "gdb_bfd.h"
#include "gcore.h"
+#include "source.h"
#include <fcntl.h>
#include "readline/readline.h"
#include <sys/stat.h>
#include "solist.h"
#include <algorithm>
+#include "common/pathstuff.h"
-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
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;
+ char *exec_file_target;
symfile_add_flags add_flags = 0;
/* Do nothing if we already have an executable filename. */
return;
}
- exec_file_host = exec_file_find (exec_file_target, NULL);
- old_chain = make_cleanup (xfree, exec_file_host);
+ gdb::unique_xmalloc_ptr<char> exec_file_host
+ = exec_file_find (exec_file_target, NULL);
if (defer_bp_reset)
add_flags |= SYMFILE_DEFER_BP_RESET;
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);
+ try_open_exec_file (exec_file_host.get (), current_inferior (), add_flags);
}
/* Set FILENAME as the new exec file.
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);
- gdb_bfd_ref_ptr exec_bfd_holder (exec_bfd);
-
- cleanups = make_cleanup (null_cleanup, NULL);
+ 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
scratch_chan = openp (getenv ("PATH"), OPF_TRY_CWD_FIRST,
filename, write_files ?
O_RDWR | O_BINARY : O_RDONLY | O_BINARY,
- &scratch_pathname);
+ &scratch_storage);
#if defined(__GO32__) || defined(_WIN32) || defined(__CYGWIN__)
if (scratch_chan < 0)
{
exename, write_files ?
O_RDWR | O_BINARY
: O_RDONLY | O_BINARY,
- &scratch_pathname);
+ &scratch_storage);
}
#endif
if (scratch_chan < 0)
perror_with_name (filename);
- make_cleanup (xfree, scratch_pathname);
+ scratch_pathname = scratch_storage.get ();
/* 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 (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 ();
+ gdb::observers::executable_changed.notify ();
}
/* Process the first arg in ARGS as the new exec file.
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
&& !query (_("A program is being debugged already.\n"
"Are you sure you want to change the file? ")))
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;
+ 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);
- table = target_get_section_table (&exec_ops);
- available_memory = section_table_available_memory (available_memory,
- offset, len,
- table->sections,
- table->sections_end);
+ normalize_mem_ranges (&available_memory);
- old_chain = make_cleanup (VEC_cleanup(mem_range_s),
- &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