/* Work with executable files, for GDB.
- Copyright (C) 1988-2020 Free Software Foundation, Inc.
+ Copyright (C) 1988-2021 Free Software Foundation, Inc.
This file is part of GDB.
const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len) override;
- struct target_section_table *get_section_table () override;
void files_info () override;
bool has_memory () override;
- char *make_corefile_notes (bfd *, int *) override;
+ gdb::unique_xmalloc_ptr<char> make_corefile_notes (bfd *, int *) override;
int find_memory_regions (find_memory_region_ftype func, void *data) override;
};
exec_file_attach (args, from_tty);
}
-/* Close and clear exec_bfd. If we end up with no target sections to
- read memory from, this unpushes the exec_ops target. */
-
-void
-exec_close (void)
-{
- if (exec_bfd)
- {
- bfd *abfd = exec_bfd;
-
- gdb_bfd_unref (abfd);
-
- /* Removing target sections may close the exec_ops target.
- Clear exec_bfd before doing so to prevent recursion. */
- exec_bfd = NULL;
- exec_bfd_mtime = 0;
-
- remove_target_sections (&exec_bfd);
-
- xfree (exec_filename);
- exec_filename = NULL;
- }
-}
-
/* This is the target_close implementation. Clears all target
sections and closes all executable bfds from all program spaces. */
void
exec_target::close ()
{
- scoped_restore_current_program_space restore_pspace;
-
for (struct program_space *ss : program_spaces)
{
- set_current_program_space (ss);
- clear_section_table (current_target_sections);
- exec_close ();
+ ss->clear_target_sections ();
+ ss->exec_close ();
}
}
reopen_exec_file ();
current_exec_file = get_exec_file (0);
- const bfd_build_id *exec_file_build_id = build_id_bfd_get (exec_bfd);
+ const bfd_build_id *exec_file_build_id
+ = build_id_bfd_get (current_program_space->exec_bfd ());
if (exec_file_build_id != nullptr)
{
/* Prepend the target prefix, to force gdb_bfd_open to open the
void
exec_file_attach (const char *filename, int from_tty)
{
- /* First, acquire a reference to the current exec_bfd. We release
+ /* First, acquire a reference to the 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_ptr exec_bfd_holder = gdb_bfd_ref_ptr::new_reference (exec_bfd);
+ gdb_bfd_ref_ptr exec_bfd_holder
+ = gdb_bfd_ref_ptr::new_reference (current_program_space->exec_bfd ());
/* Remove any previous exec file. */
- exec_close ();
+ current_program_space->exec_close ();
/* Now open and digest the file the user requested, if any. */
if (!filename)
{
if (from_tty)
- printf_unfiltered (_("No executable file now.\n"));
+ printf_unfiltered (_("No executable file now.\n"));
set_gdbarch_from_file (NULL);
}
int load_via_target = 0;
const char *scratch_pathname, *canonical_pathname;
int scratch_chan;
- struct target_section *sections = NULL, *sections_end = NULL;
char **matching;
if (is_target_filename (filename))
FOPEN_RUB, scratch_chan);
else
temp = gdb_bfd_open (canonical_pathname, gnutarget, scratch_chan);
- exec_bfd = temp.release ();
+ current_program_space->set_exec_bfd (std::move (temp));
- if (!exec_bfd)
+ if (!current_program_space->exec_bfd ())
{
- error (_("\"%ps\": could not open as an executable file: %s."),
- styled_string (file_name_style.style (), scratch_pathname),
- bfd_errmsg (bfd_get_error ()));
+ error (_("\"%s\": could not open as an executable file: %s."),
+ scratch_pathname, bfd_errmsg (bfd_get_error ()));
}
/* gdb_realpath_keepfile resolves symlinks on the local
filesystem and so cannot be used for "target:" files. */
- gdb_assert (exec_filename == NULL);
+ gdb_assert (current_program_space->exec_filename == nullptr);
if (load_via_target)
- exec_filename = xstrdup (bfd_get_filename (exec_bfd));
+ current_program_space->exec_filename
+ = (make_unique_xstrdup
+ (bfd_get_filename (current_program_space->exec_bfd ())));
else
- exec_filename = gdb_realpath_keepfile (scratch_pathname).release ();
+ current_program_space->exec_filename
+ = gdb_realpath_keepfile (scratch_pathname);
- if (!bfd_check_format_matches (exec_bfd, bfd_object, &matching))
+ if (!bfd_check_format_matches (current_program_space->exec_bfd (),
+ bfd_object, &matching))
{
/* Make sure to close exec_bfd, or else "run" might try to use
it. */
- exec_close ();
- error (_("\"%ps\": not in executable format: %s"),
- styled_string (file_name_style.style (), scratch_pathname),
+ current_program_space->exec_close ();
+ error (_("\"%s\": not in executable format: %s"), scratch_pathname,
gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
}
- if (build_section_table (exec_bfd, §ions, §ions_end))
- {
- /* Make sure to close exec_bfd, or else "run" might try to use
- it. */
- exec_close ();
- error (_("\"%ps\": can't find the file sections: %s"),
- styled_string (file_name_style.style (), scratch_pathname),
- bfd_errmsg (bfd_get_error ()));
- }
+ target_section_table sections
+ = build_section_table (current_program_space->exec_bfd ());
- exec_bfd_mtime = bfd_get_mtime (exec_bfd);
+ current_program_space->ebfd_mtime
+ = bfd_get_mtime (current_program_space->exec_bfd ());
validate_files ();
- set_gdbarch_from_file (exec_bfd);
+ set_gdbarch_from_file (current_program_space->exec_bfd ());
/* Add the executable's sections to the current address spaces'
list of sections. This possibly pushes the exec_ops
target. */
- add_target_sections (&exec_bfd, sections, sections_end);
- xfree (sections);
+ current_program_space->add_target_sections (¤t_program_space->ebfd,
+ sections);
/* Tell display code (if any) about the changed file name. */
if (deprecated_exec_file_display_hook)
if (args)
{
/* Scan through the args and pick up the first non option arg
- as the filename. */
+ as the filename. */
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"));
+ error (_("No executable file name was specified"));
gdb::unique_xmalloc_ptr<char> filename (tilde_expand (*argv));
exec_file_attach (filename.get (), from_tty);
}
\f
-/* See exec.h. */
+/* Builds a section table, given args BFD, TABLE. */
-void
-clear_section_table (struct target_section_table *table)
-{
- xfree (table->sections);
- table->sections = table->sections_end = NULL;
-}
-
-/* Resize section table TABLE by ADJUSTMENT.
- ADJUSTMENT may be negative, in which case the caller must have already
- removed the sections being deleted.
- Returns the old size. */
-
-static int
-resize_section_table (struct target_section_table *table, int adjustment)
-{
- int old_count;
- int new_count;
-
- old_count = table->sections_end - table->sections;
-
- new_count = adjustment + old_count;
-
- if (new_count)
- {
- table->sections = XRESIZEVEC (struct target_section, table->sections,
- new_count);
- table->sections_end = table->sections + new_count;
- }
- else
- clear_section_table (table);
-
- return old_count;
-}
-
-/* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
- Returns 0 if OK, 1 on error. */
-
-int
-build_section_table (struct bfd *some_bfd, struct target_section **start,
- struct target_section **end)
+target_section_table
+build_section_table (struct bfd *some_bfd)
{
- unsigned count;
+ target_section_table table;
- count = bfd_count_sections (some_bfd);
- xfree (*start);
- *start = XNEWVEC (struct target_section, count);
- *end = *start;
for (asection *asect : gdb_bfd_sections (some_bfd))
{
flagword aflag;
if (!(aflag & SEC_ALLOC))
continue;
- (*end)->owner = NULL;
- (*end)->the_bfd_section = asect;
- (*end)->addr = bfd_section_vma (asect);
- (*end)->endaddr = (*end)->addr + bfd_section_size (asect);
- (*end)++;
+ table.emplace_back (bfd_section_vma (asect),
+ bfd_section_vma (asect) + bfd_section_size (asect),
+ asect);
}
- gdb_assert (*end <= *start + count);
-
- /* We could realloc the table, but it probably loses for most files. */
- return 0;
+ return table;
}
/* Add the sections array defined by [SECTIONS..SECTIONS_END[ to the
current set of target sections. */
void
-add_target_sections (void *owner,
- struct target_section *sections,
- struct target_section *sections_end)
+program_space::add_target_sections (void *owner,
+ const target_section_table §ions)
{
- int count;
- struct target_section_table *table = current_target_sections;
-
- count = sections_end - sections;
-
- if (count > 0)
+ if (!sections.empty ())
{
- int space = resize_section_table (table, count);
- int i;
-
- for (i = 0; i < count; ++i)
+ for (const target_section &s : sections)
{
- table->sections[space + i] = sections[i];
- table->sections[space + i].owner = owner;
+ m_target_sections.push_back (s);
+ m_target_sections.back ().owner = owner;
}
scoped_restore_current_pspace_and_thread restore_pspace_thread;
- program_space *curr_pspace = current_program_space;
/* If these are the first file sections we can provide memory
from, push the file_stratum target. Must do this in all
inferiors sharing the program space. */
for (inferior *inf : all_inferiors ())
{
- if (inf->pspace != curr_pspace)
+ if (inf->pspace != this)
continue;
if (inf->target_is_pushed (&exec_ops))
continue;
switch_to_inferior_no_thread (inf);
- push_target (&exec_ops);
+ inf->push_target (&exec_ops);
}
}
}
/* Add the sections of OBJFILE to the current set of target sections. */
void
-add_target_sections_of_objfile (struct objfile *objfile)
+program_space::add_target_sections (struct objfile *objfile)
{
- struct target_section_table *table = current_target_sections;
struct obj_section *osect;
- int space;
- unsigned count = 0;
- struct target_section *ts;
- if (objfile == NULL)
- return;
+ gdb_assert (objfile != nullptr);
/* Compute the number of sections to add. */
ALL_OBJFILE_OSECTIONS (objfile, osect)
{
if (bfd_section_size (osect->the_bfd_section) == 0)
continue;
- count++;
- }
-
- if (count == 0)
- return;
-
- space = resize_section_table (table, count);
-
- ts = table->sections + space;
-
- ALL_OBJFILE_OSECTIONS (objfile, osect)
- {
- if (bfd_section_size (osect->the_bfd_section) == 0)
- continue;
-
- gdb_assert (ts < table->sections + space + count);
-
- ts->addr = obj_section_addr (osect);
- ts->endaddr = obj_section_endaddr (osect);
- ts->the_bfd_section = osect->the_bfd_section;
- ts->owner = (void *) objfile;
- ts++;
+ m_target_sections.emplace_back (osect->addr (), osect->endaddr (),
+ osect->the_bfd_section, (void *) objfile);
}
}
OWNER must be the same value passed to add_target_sections. */
void
-remove_target_sections (void *owner)
+program_space::remove_target_sections (void *owner)
{
- struct target_section *src, *dest;
- struct target_section_table *table = current_target_sections;
-
gdb_assert (owner != NULL);
- dest = table->sections;
- for (src = table->sections; src < table->sections_end; src++)
- if (src->owner != owner)
- {
- /* Keep this section. */
- if (dest < src)
- *dest = *src;
- dest++;
- }
-
- /* If we've dropped any sections, resize the section table. */
- if (dest < src)
+ auto it = std::remove_if (m_target_sections.begin (),
+ m_target_sections.end (),
+ [&] (target_section §)
+ {
+ return sect.owner == owner;
+ });
+ m_target_sections.erase (it, m_target_sections.end ());
+
+ /* If we don't have any more sections to read memory from,
+ remove the file_stratum target from the stack of each
+ inferior sharing the program space. */
+ if (m_target_sections.empty ())
{
- int old_count;
-
- old_count = resize_section_table (table, dest - src);
+ scoped_restore_current_pspace_and_thread restore_pspace_thread;
- /* If we don't have any more sections to read memory from,
- remove the file_stratum target from the stack of each
- inferior sharing the program space. */
- if (old_count + (dest - src) == 0)
+ for (inferior *inf : all_inferiors ())
{
- scoped_restore_current_pspace_and_thread restore_pspace_thread;
- program_space *curr_pspace = current_program_space;
-
- for (inferior *inf : all_inferiors ())
- {
- if (inf->pspace != curr_pspace)
- continue;
-
- if (inf->pspace->target_sections.sections
- != inf->pspace->target_sections.sections_end)
- continue;
+ if (inf->pspace != this)
+ continue;
- switch_to_inferior_no_thread (inf);
- unpush_target (&exec_ops);
- }
+ switch_to_inferior_no_thread (inf);
+ inf->unpush_target (&exec_ops);
}
}
}
void
exec_on_vfork ()
{
- if (current_program_space->target_sections.sections
- != current_program_space->target_sections.sections_end)
- push_target (&exec_ops);
+ if (!current_program_space->target_sections ().empty ())
+ current_inferior ()->push_target (&exec_ops);
}
\f
/* It's unduly pedantic to refuse to look at the executable for
read-only pieces; so do the equivalent of readonly regions aka
QTro packet. */
- if (exec_bfd != NULL)
+ if (current_program_space->exec_bfd () != NULL)
{
asection *s;
bfd_size_type size;
bfd_vma vma;
- for (s = exec_bfd->sections; s; s = s->next)
+ for (s = current_program_space->exec_bfd ()->sections; s; s = s->next)
{
if ((s->flags & SEC_LOAD) == 0
|| (s->flags & SEC_READONLY) == 0)
if (amt > len)
amt = len;
- amt = bfd_get_section_contents (exec_bfd, s,
+ amt = bfd_get_section_contents (current_program_space->exec_bfd (), s,
readbuf, offset - vma, amt);
if (amt == 0)
static std::vector<mem_range>
section_table_available_memory (CORE_ADDR memaddr, ULONGEST len,
- struct target_section *sections,
- struct target_section *sections_end)
+ const target_section_table §ions)
{
std::vector<mem_range> memory;
- for (target_section *p = sections; p < sections_end; p++)
+ for (const target_section &p : sections)
{
- if ((bfd_section_flags (p->the_bfd_section) & SEC_READONLY) == 0)
+ if ((bfd_section_flags (p.the_bfd_section) & SEC_READONLY) == 0)
continue;
/* Copy the meta-data, adjusted. */
- if (mem_ranges_overlap (p->addr, p->endaddr - p->addr, memaddr, len))
+ if (mem_ranges_overlap (p.addr, p.endaddr - p.addr, memaddr, len))
{
ULONGEST lo1, hi1, lo2, hi2;
lo1 = memaddr;
hi1 = memaddr + len;
- lo2 = p->addr;
- hi2 = p->endaddr;
+ lo2 = p.addr;
+ hi2 = p.endaddr;
CORE_ADDR start = std::max (lo1, lo2);
int length = std::min (hi1, hi2) - start;
section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
ULONGEST len, ULONGEST *xfered_len)
{
- target_section_table *table = target_get_section_table (&exec_ops);
+ const target_section_table *table
+ = target_get_section_table (current_inferior ()->top_target ());
std::vector<mem_range> available_memory
- = section_table_available_memory (offset, len,
- table->sections, table->sections_end);
+ = section_table_available_memory (offset, len, *table);
normalize_mem_ranges (&available_memory);
section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len,
ULONGEST *xfered_len,
- struct target_section *sections,
- struct target_section *sections_end,
+ const target_section_table §ions,
gdb::function_view<bool
(const struct target_section *)> match_cb)
{
int res;
- struct target_section *p;
ULONGEST memaddr = offset;
ULONGEST memend = memaddr + len;
gdb_assert (len != 0);
- for (p = sections; p < sections_end; p++)
+ for (const target_section &p : sections)
{
- struct bfd_section *asect = p->the_bfd_section;
+ struct bfd_section *asect = p.the_bfd_section;
bfd *abfd = asect->owner;
- if (match_cb != nullptr && !match_cb (p))
+ if (match_cb != nullptr && !match_cb (&p))
continue; /* not the section we need. */
- if (memaddr >= p->addr)
- {
- if (memend <= p->endaddr)
+ if (memaddr >= p.addr)
+ {
+ if (memend <= p.endaddr)
{
/* Entire transfer is within this section. */
if (writebuf)
res = bfd_set_section_contents (abfd, asect,
- writebuf, memaddr - p->addr,
+ writebuf, memaddr - p.addr,
len);
else
res = bfd_get_section_contents (abfd, asect,
- readbuf, memaddr - p->addr,
+ readbuf, memaddr - p.addr,
len);
if (res != 0)
else
return TARGET_XFER_EOF;
}
- else if (memaddr >= p->endaddr)
+ else if (memaddr >= p.endaddr)
{
/* This section ends before the transfer starts. */
continue;
else
{
/* This section overlaps the transfer. Just do half. */
- len = p->endaddr - memaddr;
+ len = p.endaddr - memaddr;
if (writebuf)
res = bfd_set_section_contents (abfd, asect,
- writebuf, memaddr - p->addr,
+ writebuf, memaddr - p.addr,
len);
else
res = bfd_get_section_contents (abfd, asect,
- readbuf, memaddr - p->addr,
+ readbuf, memaddr - p.addr,
len);
if (res != 0)
{
else
return TARGET_XFER_EOF;
}
- }
+ }
}
return TARGET_XFER_EOF; /* We can't help. */
}
-struct target_section_table *
-exec_target::get_section_table ()
-{
- return current_target_sections;
-}
-
enum target_xfer_status
exec_target::xfer_partial (enum target_object object,
const char *annex, gdb_byte *readbuf,
const gdb_byte *writebuf,
ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
{
- struct target_section_table *table = get_section_table ();
+ const target_section_table *table = target_get_section_table (this);
if (object == TARGET_OBJECT_MEMORY)
return section_table_xfer_memory_partial (readbuf, writebuf,
offset, len, xfered_len,
- table->sections,
- table->sections_end);
+ *table);
else
return TARGET_XFER_E_IO;
}
\f
void
-print_section_info (struct target_section_table *t, bfd *abfd)
+print_section_info (const target_section_table *t, bfd *abfd)
{
struct gdbarch *gdbarch = gdbarch_from_bfd (abfd);
- struct target_section *p;
/* FIXME: 16 is not wide enough when gdbarch_addr_bit > 64. */
int wid = gdbarch_addr_bit (gdbarch) <= 32 ? 8 : 16;
bfd_get_filename (abfd)));
wrap_here (" ");
printf_filtered (_("file type %s.\n"), bfd_get_target (abfd));
- if (abfd == exec_bfd)
+ if (abfd == current_program_space->exec_bfd ())
{
/* gcc-3.4 does not like the initialization in
<p == t->sections_end>. */
bfd_vma displacement = 0;
bfd_vma entry_point;
+ bool found = false;
- for (p = t->sections; p < t->sections_end; p++)
+ for (const target_section &p : *t)
{
- struct bfd_section *psect = p->the_bfd_section;
+ struct bfd_section *psect = p.the_bfd_section;
if ((bfd_section_flags (psect) & (SEC_ALLOC | SEC_LOAD))
!= (SEC_ALLOC | SEC_LOAD))
&& abfd->start_address < (bfd_section_vma (psect)
+ bfd_section_size (psect)))
{
- displacement = p->addr - bfd_section_vma (psect);
+ displacement = p.addr - bfd_section_vma (psect);
+ found = true;
break;
}
}
- if (p == t->sections_end)
+ if (!found)
warning (_("Cannot find section for the entry point of %ps."),
styled_string (file_name_style.style (),
bfd_get_filename (abfd)));
printf_filtered (_("\tEntry point: %s\n"),
paddress (gdbarch, entry_point));
}
- for (p = t->sections; p < t->sections_end; p++)
+ for (const target_section &p : *t)
{
- struct bfd_section *psect = p->the_bfd_section;
+ struct bfd_section *psect = p.the_bfd_section;
bfd *pbfd = psect->owner;
- printf_filtered ("\t%s", hex_string_custom (p->addr, wid));
- printf_filtered (" - %s", hex_string_custom (p->endaddr, wid));
+ printf_filtered ("\t%s", hex_string_custom (p.addr, wid));
+ printf_filtered (" - %s", hex_string_custom (p.endaddr, wid));
/* FIXME: A format of "08l" is not wide enough for file offsets
larger than 4GB. OTOH, making it "016l" isn't desirable either
void
exec_target::files_info ()
{
- if (exec_bfd)
- print_section_info (current_target_sections, exec_bfd);
+ if (current_program_space->exec_bfd ())
+ print_section_info (¤t_program_space->target_sections (),
+ current_program_space->exec_bfd ());
else
puts_filtered (_("\t<no file loaded>\n"));
}
static void
set_section_command (const char *args, int from_tty)
{
- struct target_section *p;
const char *secname;
- unsigned seclen;
- unsigned long secaddr;
- char secprint[100];
- long offset;
- struct target_section_table *table;
if (args == 0)
error (_("Must specify section name and its virtual address"));
/* Parse out section name. */
for (secname = args; !isspace (*args); args++);
- seclen = args - secname;
+ unsigned seclen = args - secname;
/* Parse out new virtual address. */
- secaddr = parse_and_eval_address (args);
+ CORE_ADDR secaddr = parse_and_eval_address (args);
- table = current_target_sections;
- for (p = table->sections; p < table->sections_end; p++)
+ for (target_section &p : current_program_space->target_sections ())
{
- if (!strncmp (secname, bfd_section_name (p->the_bfd_section), seclen)
- && bfd_section_name (p->the_bfd_section)[seclen] == '\0')
+ if (!strncmp (secname, bfd_section_name (p.the_bfd_section), seclen)
+ && bfd_section_name (p.the_bfd_section)[seclen] == '\0')
{
- offset = secaddr - p->addr;
- p->addr += offset;
- p->endaddr += offset;
+ long offset = secaddr - p.addr;
+ p.addr += offset;
+ p.endaddr += offset;
if (from_tty)
exec_ops.files_info ();
return;
}
}
- if (seclen >= sizeof (secprint))
- seclen = sizeof (secprint) - 1;
- strncpy (secprint, secname, seclen);
- secprint[seclen] = '\0';
- error (_("Section %s not found"), secprint);
+
+ std::string secprint (secname, seclen);
+ error (_("Section %s not found"), secprint.c_str ());
}
/* If we can find a section in FILENAME with BFD index INDEX, adjust
void
exec_set_section_address (const char *filename, int index, CORE_ADDR address)
{
- struct target_section *p;
- struct target_section_table *table;
-
- table = current_target_sections;
- for (p = table->sections; p < table->sections_end; p++)
+ for (target_section &p : current_program_space->target_sections ())
{
if (filename_cmp (filename,
- bfd_get_filename (p->the_bfd_section->owner)) == 0
- && index == p->the_bfd_section->index)
+ bfd_get_filename (p.the_bfd_section->owner)) == 0
+ && index == p.the_bfd_section->index)
{
- p->endaddr += address - p->addr;
- p->addr = address;
+ p.endaddr += address - p.addr;
+ p.addr = address;
}
}
}
{
/* We can provide memory if we have any file/target sections to read
from. */
- return (current_target_sections->sections
- != current_target_sections->sections_end);
+ return !current_program_space->target_sections ().empty ();
}
-char *
+gdb::unique_xmalloc_ptr<char>
exec_target::make_corefile_notes (bfd *obfd, int *note_size)
{
error (_("Can't create a corefile"));
projects / deliverable / binutils-gdb.git / blobdiff