[PATCH 2/6] Use a std::vector in target_section_table
Luis Machado
luis.machado@linaro.org
Tue Oct 13 16:41:52 GMT 2020
Hi,
FTR, this has regressed AArch64-linux...
FAIL: gdb.base/corefile2.exp: renamed binfile: print/x mbuf_ro[0]@4
FAIL: gdb.base/corefile2.exp: renamed binfile: print/x mbuf_ro[pagesize-4]@4
FAIL: gdb.base/corefile2.exp: renamed binfile: print/x mbuf_ro[-3]@6
FAIL: gdb.base/corefile2.exp: renamed binfile: print/x mbuf_rw[pagesize-3]@6
FAIL: gdb.base/corefile2.exp: renamed binfile: print/x mbuf_ro[pagesize-3]@6
I haven't investigated the failure, but I've bisected the failure to
this commit.
On 10/3/20 4:37 PM, Tom Tromey wrote:
> This changes target_section_table to wrap a std::vector. This
> simplifies some code, and also enables the simplifications coming in
> the subsequent patches.
>
> Note that for solib, I chose to have it use a pointer to a
> target_section_table. This is more convoluted than would be ideal,
> but I didn't want to convert solib to new/delete as a prerequisite for
> this series.
>
> gdb/ChangeLog
> 2020-10-03 Tom Tromey <tom@tromey.com>
>
> * target.c (target_section_by_addr, memory_xfer_partial_1):
> Update.
> * target-section.h (struct target_section_table): Use
> std::vector.
> * symfile.h (build_section_addr_info_from_section_table): Take a
> target_section_table.
> * symfile.c (build_section_addr_info_from_section_table): Take a
> target_section_table.
> * solist.h (struct so_list) <sections>: Change type.
> <sections_end>: Remove.
> * solib.c (solib_map_sections, clear_so, solib_read_symbols)
> (solib_contains_address_p): Update.
> * solib-svr4.c (scan_dyntag): Update.
> * solib-dsbt.c (scan_dyntag): Update.
> * remote.c (remote_target::remote_xfer_live_readonly_partial):
> Update.
> * record-full.c (record_full_core_start, record_full_core_end):
> Remove.
> (record_full_core_sections): New global.
> (record_full_core_open_1, record_full_core_target::xfer_partial):
> Update.
> * exec.h (build_section_table, section_table_xfer_memory_partial)
> (add_target_sections): Take a target_section_table.
> * exec.c (exec_file_attach, clear_section_table): Update.
> (resize_section_table): Remove.
> (build_section_table, add_target_sections): Take a
> target_section_table.
> (add_target_sections_of_objfile, remove_target_sections)
> (exec_on_vfork): Update.
> (section_table_available_memory): Take a target_section_table.
> (section_table_read_available_memory): Update.
> (section_table_xfer_memory_partial): Take a target_section_table.
> (print_section_info, set_section_command)
> (exec_set_section_address, exec_target::has_memory): Update.
> * corelow.c (class core_target) <m_core_section_table,
> m_core_file_mappings>: Remove braces.
> <~core_target>: Remove.
> (core_target::core_target): Update.
> (core_target::~core_target): Remove.
> (core_target::build_file_mappings)
> (core_target::xfer_memory_via_mappings)
> (core_target::xfer_partial, core_target::info_proc_mappings):
> Update.
> * bfd-target.c (target_bfd::xfer_partial): Update.
> (target_bfd::target_bfd): Update.
> (target_bfd::~target_bfd): Remove.
> ---
> gdb/ChangeLog | 49 +++++++++
> gdb/bfd-target.c | 13 +--
> gdb/corelow.c | 58 ++++------
> gdb/exec.c | 247 +++++++++++++++----------------------------
> gdb/exec.h | 9 +-
> gdb/record-full.c | 33 +++---
> gdb/remote.c | 11 +-
> gdb/solib-dsbt.c | 18 ++--
> gdb/solib-svr4.c | 18 ++--
> gdb/solib.c | 33 +++---
> gdb/solist.h | 4 +-
> gdb/symfile.c | 13 +--
> gdb/symfile.h | 6 +-
> gdb/target-section.h | 5 +-
> gdb/target.c | 14 +--
> 15 files changed, 230 insertions(+), 301 deletions(-)
>
> diff --git a/gdb/bfd-target.c b/gdb/bfd-target.c
> index 3d266951c5a..8a58e92eb1c 100644
> --- a/gdb/bfd-target.c
> +++ b/gdb/bfd-target.c
> @@ -35,7 +35,6 @@ class target_bfd : public target_ops
> {
> public:
> explicit target_bfd (struct bfd *bfd);
> - ~target_bfd () override;
>
> const target_info &info () const override
> { return target_bfd_target_info; }
> @@ -76,8 +75,7 @@ target_bfd::xfer_partial (target_object object,
> {
> return section_table_xfer_memory_partial (readbuf, writebuf,
> offset, len, xfered_len,
> - m_table.sections,
> - m_table.sections_end);
> + m_table);
> }
> default:
> return TARGET_XFER_E_IO;
> @@ -93,14 +91,7 @@ target_bfd::get_section_table ()
> target_bfd::target_bfd (struct bfd *abfd)
> : m_bfd (gdb_bfd_ref_ptr::new_reference (abfd))
> {
> - m_table.sections = NULL;
> - m_table.sections_end = NULL;
> - build_section_table (abfd, &m_table.sections, &m_table.sections_end);
> -}
> -
> -target_bfd::~target_bfd ()
> -{
> - xfree (m_table.sections);
> + build_section_table (abfd, &m_table);
> }
>
> target_ops *
> diff --git a/gdb/corelow.c b/gdb/corelow.c
> index e82c183eae5..554561dbb36 100644
> --- a/gdb/corelow.c
> +++ b/gdb/corelow.c
> @@ -67,7 +67,6 @@ class core_target final : public process_stratum_target
> {
> public:
> core_target ();
> - ~core_target () override;
>
> const target_info &info () const override
> { return core_target_info; }
> @@ -126,11 +125,11 @@ class core_target final : public process_stratum_target
> shared library bfds. The core bfd sections are an implementation
> detail of the core target, just like ptrace is for unix child
> targets. */
> - target_section_table m_core_section_table {};
> + target_section_table m_core_section_table;
>
> /* File-backed address space mappings: some core files include
> information about memory mapped files. */
> - target_section_table m_core_file_mappings {};
> + target_section_table m_core_file_mappings;
>
> /* Unavailable mappings. These correspond to pathnames which either
> weren't found or could not be opened. Knowing these addresses can
> @@ -162,21 +161,13 @@ core_target::core_target ()
> bfd_get_filename (core_bfd));
>
> /* Find the data section */
> - if (build_section_table (core_bfd,
> - &m_core_section_table.sections,
> - &m_core_section_table.sections_end))
> + if (build_section_table (core_bfd, &m_core_section_table))
> error (_("\"%s\": Can't find sections: %s"),
> bfd_get_filename (core_bfd), bfd_errmsg (bfd_get_error ()));
>
> build_file_mappings ();
> }
>
> -core_target::~core_target ()
> -{
> - xfree (m_core_section_table.sections);
> - xfree (m_core_file_mappings.sections);
> -}
> -
> /* Construct the target_section_table for file-backed mappings if
> they exist.
>
> @@ -202,12 +193,9 @@ core_target::build_file_mappings ()
> gdbarch_read_core_file_mappings (m_core_gdbarch, core_bfd,
>
> /* After determining the number of mappings, read_core_file_mappings
> - will invoke this lambda which allocates target_section storage for
> - the mappings. */
> - [&] (ULONGEST count)
> + will invoke this lambda. */
> + [&] (ULONGEST)
> {
> - m_core_file_mappings.sections = XNEWVEC (struct target_section, count);
> - m_core_file_mappings.sections_end = m_core_file_mappings.sections;
> },
>
> /* read_core_file_mappings will invoke this lambda for each mapping
> @@ -280,11 +268,12 @@ core_target::build_file_mappings ()
> bfd_set_section_alignment (sec, 2);
>
> /* Set target_section fields. */
> - struct target_section *ts = m_core_file_mappings.sections_end++;
> - ts->addr = start;
> - ts->endaddr = end;
> - ts->owner = nullptr;
> - ts->the_bfd_section = sec;
> + m_core_file_mappings.sections.emplace_back ();
> + target_section &ts = m_core_file_mappings.sections.back ();
> + ts.addr = start;
> + ts.endaddr = end;
> + ts.owner = nullptr;
> + ts.the_bfd_section = sec;
> });
>
> normalize_mem_ranges (&m_core_unavailable_mappings);
> @@ -759,8 +748,7 @@ core_target::xfer_memory_via_mappings (gdb_byte *readbuf,
> xfer_status = (section_table_xfer_memory_partial
> (readbuf, writebuf,
> offset, len, xfered_len,
> - m_core_file_mappings.sections,
> - m_core_file_mappings.sections_end));
> + m_core_file_mappings));
>
> if (xfer_status == TARGET_XFER_OK || m_core_unavailable_mappings.empty ())
> return xfer_status;
> @@ -818,8 +806,7 @@ core_target::xfer_partial (enum target_object object, const char *annex,
> xfer_status = section_table_xfer_memory_partial
> (readbuf, writebuf,
> offset, len, xfered_len,
> - m_core_section_table.sections,
> - m_core_section_table.sections_end,
> + m_core_section_table,
> has_contents_cb);
> if (xfer_status == TARGET_XFER_OK)
> return TARGET_XFER_OK;
> @@ -829,7 +816,7 @@ core_target::xfer_partial (enum target_object object, const char *annex,
> or the like) as this should provide a more accurate
> result. If not, check the stratum beneath us, which should
> be the file stratum. */
> - if (m_core_file_mappings.sections != nullptr)
> + if (!m_core_file_mappings.sections.empty ())
> xfer_status = xfer_memory_via_mappings (readbuf, writebuf, offset,
> len, xfered_len);
> else
> @@ -848,8 +835,7 @@ core_target::xfer_partial (enum target_object object, const char *annex,
> xfer_status = section_table_xfer_memory_partial
> (readbuf, writebuf,
> offset, len, xfered_len,
> - m_core_section_table.sections,
> - m_core_section_table.sections_end,
> + m_core_section_table,
> no_contents_cb);
>
> return xfer_status;
> @@ -1114,7 +1100,7 @@ get_current_core_target ()
> void
> core_target::info_proc_mappings (struct gdbarch *gdbarch)
> {
> - if (m_core_file_mappings.sections != m_core_file_mappings.sections_end)
> + if (!m_core_file_mappings.sections.empty ())
> {
> printf_filtered (_("Mapped address spaces:\n\n"));
> if (gdbarch_addr_bit (gdbarch) == 32)
> @@ -1133,14 +1119,12 @@ core_target::info_proc_mappings (struct gdbarch *gdbarch)
> }
> }
>
> - for (const struct target_section *tsp = m_core_file_mappings.sections;
> - tsp < m_core_file_mappings.sections_end;
> - tsp++)
> + for (const target_section &tsp : m_core_file_mappings.sections)
> {
> - ULONGEST start = tsp->addr;
> - ULONGEST end = tsp->endaddr;
> - ULONGEST file_ofs = tsp->the_bfd_section->filepos;
> - const char *filename = bfd_get_filename (tsp->the_bfd_section->owner);
> + ULONGEST start = tsp.addr;
> + ULONGEST end = tsp.endaddr;
> + ULONGEST file_ofs = tsp.the_bfd_section->filepos;
> + const char *filename = bfd_get_filename (tsp.the_bfd_section->owner);
>
> if (gdbarch_addr_bit (gdbarch) == 32)
> printf_filtered ("\t%10s %10s %10s %10s %s\n",
> diff --git a/gdb/exec.c b/gdb/exec.c
> index 251e24dd26b..e3e515fedec 100644
> --- a/gdb/exec.c
> +++ b/gdb/exec.c
> @@ -413,7 +413,7 @@ exec_file_attach (const char *filename, int from_tty)
> int load_via_target = 0;
> const char *scratch_pathname, *canonical_pathname;
> int scratch_chan;
> - struct target_section *sections = NULL, *sections_end = NULL;
> + target_section_table sections;
> char **matching;
>
> if (is_target_filename (filename))
> @@ -503,7 +503,7 @@ exec_file_attach (const char *filename, int from_tty)
> gdb_bfd_errmsg (bfd_get_error (), matching).c_str ());
> }
>
> - if (build_section_table (exec_bfd, §ions, §ions_end))
> + if (build_section_table (exec_bfd, §ions))
> {
> /* Make sure to close exec_bfd, or else "run" might try to use
> it. */
> @@ -522,8 +522,7 @@ exec_file_attach (const char *filename, int from_tty)
> /* 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);
> + add_target_sections (&exec_bfd, sections);
>
> /* Tell display code (if any) about the changed file name. */
> if (deprecated_exec_file_display_hook)
> @@ -592,50 +591,16 @@ file_command (const char *arg, int from_tty)
> void
> clear_section_table (struct target_section_table *table)
> {
> - xfree (table->sections);
> - table->sections = table->sections_end = NULL;
> + table->sections.clear ();
> }
>
> -/* 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.
> +/* Builds a section table, given args BFD, TABLE.
> Returns 0 if OK, 1 on error. */
>
> int
> -build_section_table (struct bfd *some_bfd, struct target_section **start,
> - struct target_section **end)
> +build_section_table (struct bfd *some_bfd, target_section_table *table)
> {
> - unsigned count;
> -
> - count = bfd_count_sections (some_bfd);
> - xfree (*start);
> - *start = XNEWVEC (struct target_section, count);
> - *end = *start;
> + table->sections.clear ();
> for (asection *asect : gdb_bfd_sections (some_bfd))
> {
> flagword aflag;
> @@ -650,15 +615,14 @@ build_section_table (struct bfd *some_bfd, struct target_section **start,
> 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->sections.emplace_back ();
> + target_section § = table->sections.back ();
> + sect.owner = NULL;
> + sect.the_bfd_section = asect;
> + sect.addr = bfd_section_vma (asect);
> + sect.endaddr = sect.addr + bfd_section_size (asect);
> }
>
> - gdb_assert (*end <= *start + count);
> -
> /* We could realloc the table, but it probably loses for most files. */
> return 0;
> }
> @@ -668,23 +632,16 @@ build_section_table (struct bfd *some_bfd, struct target_section **start,
>
> void
> add_target_sections (void *owner,
> - struct target_section *sections,
> - struct target_section *sections_end)
> + const target_section_table §ions)
> {
> - int count;
> struct target_section_table *table = current_target_sections;
>
> - count = sections_end - sections;
> -
> - if (count > 0)
> + if (!sections.sections.empty ())
> {
> - int space = resize_section_table (table, count);
> - int i;
> -
> - for (i = 0; i < count; ++i)
> + for (const target_section &s : sections.sections)
> {
> - table->sections[space + i] = sections[i];
> - table->sections[space + i].owner = owner;
> + table->sections.push_back (s);
> + table->sections.back ().owner = owner;
> }
>
> scoped_restore_current_pspace_and_thread restore_pspace_thread;
> @@ -714,9 +671,7 @@ add_target_sections_of_objfile (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;
> @@ -732,23 +687,17 @@ add_target_sections_of_objfile (struct objfile *objfile)
> 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++;
> + table->sections.emplace_back ();
> + target_section &ts = table->sections.back ();
> + ts.addr = obj_section_addr (osect);
> + ts.endaddr = obj_section_endaddr (osect);
> + ts.the_bfd_section = osect->the_bfd_section;
> + ts.owner = (void *) objfile;
> }
> }
>
> @@ -758,48 +707,36 @@ add_target_sections_of_objfile (struct objfile *objfile)
> void
> 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 (table->sections.begin (),
> + table->sections.end (),
> + [&] (target_section §)
> + {
> + return sect.owner == owner;
> + });
> + table->sections.erase (it, table->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 (table->sections.empty ())
> {
> - int old_count;
> -
> - old_count = resize_section_table (table, dest - src);
> + scoped_restore_current_pspace_and_thread restore_pspace_thread;
> + program_space *curr_pspace = current_program_space;
>
> - /* 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 != curr_pspace)
> + continue;
>
> - if (inf->pspace->target_sections.sections
> - != inf->pspace->target_sections.sections_end)
> - continue;
> + if (!inf->pspace->target_sections.sections.empty ())
> + continue;
>
> - switch_to_inferior_no_thread (inf);
> - unpush_target (&exec_ops);
> - }
> + switch_to_inferior_no_thread (inf);
> + unpush_target (&exec_ops);
> }
> }
> }
> @@ -809,8 +746,7 @@ remove_target_sections (void *owner)
> void
> exec_on_vfork ()
> {
> - if (current_program_space->target_sections.sections
> - != current_program_space->target_sections.sections_end)
> + if (!current_program_space->target_sections.sections.empty ())
> push_target (&exec_ops);
> }
>
> @@ -869,26 +805,25 @@ exec_read_partial_read_only (gdb_byte *readbuf, ULONGEST offset,
>
> 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.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;
> @@ -906,8 +841,7 @@ section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
> {
> 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);
> + = section_table_available_memory (offset, len, *table);
>
> normalize_mem_ranges (&available_memory);
>
> @@ -944,37 +878,35 @@ enum target_xfer_status
> 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.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 (memaddr >= p.addr)
> {
> - if (memend <= p->endaddr)
> + 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)
> @@ -985,7 +917,7 @@ section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
> else
> return TARGET_XFER_EOF;
> }
> - else if (memaddr >= p->endaddr)
> + else if (memaddr >= p.endaddr)
> {
> /* This section ends before the transfer starts. */
> continue;
> @@ -993,14 +925,14 @@ section_table_xfer_memory_partial (gdb_byte *readbuf, const gdb_byte *writebuf,
> 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)
> {
> @@ -1033,8 +965,7 @@ exec_target::xfer_partial (enum target_object object,
> 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;
> }
> @@ -1044,7 +975,6 @@ void
> print_section_info (struct 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;
>
> @@ -1059,10 +989,11 @@ print_section_info (struct target_section_table *t, bfd *abfd)
> <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->sections)
> {
> - 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))
> @@ -1072,11 +1003,12 @@ print_section_info (struct target_section_table *t, bfd *abfd)
> && 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)));
> @@ -1087,13 +1019,13 @@ print_section_info (struct target_section_table *t, bfd *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->sections)
> {
> - 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
> @@ -1125,7 +1057,6 @@ exec_target::files_info ()
> static void
> set_section_command (const char *args, int from_tty)
> {
> - struct target_section *p;
> const char *secname;
> unsigned seclen;
> unsigned long secaddr;
> @@ -1144,14 +1075,14 @@ set_section_command (const char *args, int from_tty)
> secaddr = parse_and_eval_address (args);
>
> table = current_target_sections;
> - for (p = table->sections; p < table->sections_end; p++)
> + for (target_section &p : table->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;
> + offset = secaddr - p.addr;
> + p.addr += offset;
> + p.endaddr += offset;
> if (from_tty)
> exec_ops.files_info ();
> return;
> @@ -1170,18 +1101,17 @@ set_section_command (const char *args, int from_tty)
> 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 : table->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;
> }
> }
> }
> @@ -1191,8 +1121,7 @@ exec_target::has_memory ()
> {
> /* 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_target_sections->sections.empty ();
> }
>
> char *
> diff --git a/gdb/exec.h b/gdb/exec.h
> index 82eb39c55d8..d26eba49236 100644
> --- a/gdb/exec.h
> +++ b/gdb/exec.h
> @@ -37,8 +37,7 @@ struct objfile;
> /* Builds a section table, given args BFD, SECTABLE_PTR, SECEND_PTR.
> Returns 0 if OK, 1 on error. */
>
> -extern int build_section_table (struct bfd *, struct target_section **,
> - struct target_section **);
> +extern int build_section_table (struct bfd *, struct target_section_table *);
>
> /* Remove all entries from TABLE. */
>
> @@ -86,8 +85,7 @@ extern enum target_xfer_status
> section_table_xfer_memory_partial (gdb_byte *,
> const gdb_byte *,
> ULONGEST, ULONGEST, ULONGEST *,
> - struct target_section *,
> - struct target_section *,
> + const target_section_table &,
> gdb::function_view<bool
> (const struct target_section *)> match_cb
> = nullptr);
> @@ -111,8 +109,7 @@ extern void remove_target_sections (void *owner);
> current set of target sections. */
>
> extern void add_target_sections (void *owner,
> - struct target_section *sections,
> - struct target_section *sections_end);
> + const target_section_table §ions);
>
> /* Add the sections of OBJFILE to the current set of target sections.
> * OBJFILE owns the new target sections. */
> diff --git a/gdb/record-full.c b/gdb/record-full.c
> index 9a6187e8104..5dcb42d2f4e 100644
> --- a/gdb/record-full.c
> +++ b/gdb/record-full.c
> @@ -171,8 +171,7 @@ struct record_full_core_buf_entry
>
> /* Record buf with core target. */
> static detached_regcache *record_full_core_regbuf = NULL;
> -static struct target_section *record_full_core_start;
> -static struct target_section *record_full_core_end;
> +static target_section_table record_full_core_sections;
> static struct record_full_core_buf_entry *record_full_core_buf_list = NULL;
>
> /* The following variables are used for managing the linked list that
> @@ -924,9 +923,7 @@ record_full_core_open_1 (const char *name, int from_tty)
> for (i = 0; i < regnum; i ++)
> record_full_core_regbuf->raw_supply (i, *regcache);
>
> - /* Get record_full_core_start and record_full_core_end. */
> - if (build_section_table (core_bfd, &record_full_core_start,
> - &record_full_core_end))
> + if (build_section_table (core_bfd, &record_full_core_sections))
> {
> delete record_full_core_regbuf;
> record_full_core_regbuf = NULL;
> @@ -2147,27 +2144,25 @@ record_full_core_target::xfer_partial (enum target_object object,
> {
> if (record_full_gdb_operation_disable || !writebuf)
> {
> - struct target_section *p;
> -
> - for (p = record_full_core_start; p < record_full_core_end; p++)
> + for (target_section &p : record_full_core_sections.sections)
> {
> - if (offset >= p->addr)
> + if (offset >= p.addr)
> {
> struct record_full_core_buf_entry *entry;
> ULONGEST sec_offset;
>
> - if (offset >= p->endaddr)
> + if (offset >= p.endaddr)
> continue;
>
> - if (offset + len > p->endaddr)
> - len = p->endaddr - offset;
> + if (offset + len > p.endaddr)
> + len = p.endaddr - offset;
>
> - sec_offset = offset - p->addr;
> + sec_offset = offset - p.addr;
>
> /* Read readbuf or write writebuf p, offset, len. */
> /* Check flags. */
> - if (p->the_bfd_section->flags & SEC_CONSTRUCTOR
> - || (p->the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
> + if (p.the_bfd_section->flags & SEC_CONSTRUCTOR
> + || (p.the_bfd_section->flags & SEC_HAS_CONTENTS) == 0)
> {
> if (readbuf)
> memset (readbuf, 0, len);
> @@ -2178,7 +2173,7 @@ record_full_core_target::xfer_partial (enum target_object object,
> /* Get record_full_core_buf_entry. */
> for (entry = record_full_core_buf_list; entry;
> entry = entry->prev)
> - if (entry->p == p)
> + if (entry->p == &p)
> break;
> if (writebuf)
> {
> @@ -2186,10 +2181,10 @@ record_full_core_target::xfer_partial (enum target_object object,
> {
> /* Add a new entry. */
> entry = XNEW (struct record_full_core_buf_entry);
> - entry->p = p;
> + entry->p = &p;
> if (!bfd_malloc_and_get_section
> - (p->the_bfd_section->owner,
> - p->the_bfd_section,
> + (p.the_bfd_section->owner,
> + p.the_bfd_section,
> &entry->buf))
> {
> xfree (entry);
> diff --git a/gdb/remote.c b/gdb/remote.c
> index f95148643f8..c9c5ed03ea2 100644
> --- a/gdb/remote.c
> +++ b/gdb/remote.c
> @@ -8895,22 +8895,21 @@ remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
> if (secp != NULL
> && (bfd_section_flags (secp->the_bfd_section) & SEC_READONLY))
> {
> - struct target_section *p;
> ULONGEST memend = memaddr + len;
>
> table = target_get_section_table (this);
>
> - for (p = table->sections; p < table->sections_end; p++)
> + for (target_section &p : table->sections)
> {
> - if (memaddr >= p->addr)
> + if (memaddr >= p.addr)
> {
> - if (memend <= p->endaddr)
> + if (memend <= p.endaddr)
> {
> /* Entire transfer is within this section. */
> return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
> xfered_len);
> }
> - else if (memaddr >= p->endaddr)
> + else if (memaddr >= p.endaddr)
> {
> /* This section ends before the transfer starts. */
> continue;
> @@ -8918,7 +8917,7 @@ remote_target::remote_xfer_live_readonly_partial (gdb_byte *readbuf,
> else
> {
> /* This section overlaps the transfer. Just do half. */
> - len = p->endaddr - memaddr;
> + len = p.endaddr - memaddr;
> return remote_read_bytes_1 (memaddr, readbuf, len, unit_size,
> xfered_len);
> }
> diff --git a/gdb/solib-dsbt.c b/gdb/solib-dsbt.c
> index 0f146725dba..59089216314 100644
> --- a/gdb/solib-dsbt.c
> +++ b/gdb/solib-dsbt.c
> @@ -407,7 +407,6 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
> Elf32_External_Dyn *x_dynp_32;
> Elf64_External_Dyn *x_dynp_64;
> struct bfd_section *sect;
> - struct target_section *target_section;
>
> if (abfd == NULL)
> return 0;
> @@ -424,14 +423,15 @@ scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
> if (sect == NULL)
> return 0;
>
> - for (target_section = current_target_sections->sections;
> - target_section < current_target_sections->sections_end;
> - target_section++)
> - if (sect == target_section->the_bfd_section)
> - break;
> - if (target_section < current_target_sections->sections_end)
> - dyn_addr = target_section->addr;
> - else
> + bool found = false;
> + for (target_section &target_section : current_target_sections->sections)
> + if (sect == target_section.the_bfd_section)
> + {
> + dyn_addr = target_section.addr;
> + found = true;
> + break;
> + }
> + if (!found)
> {
> /* ABFD may come from OBJFILE acting only as a symbol file without being
> loaded into the target (see add_symbol_file_command). This case is
> diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c
> index 4ae21d190bf..9bb728ae9b9 100644
> --- a/gdb/solib-svr4.c
> +++ b/gdb/solib-svr4.c
> @@ -591,7 +591,6 @@ scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr,
> Elf32_External_Dyn *x_dynp_32;
> Elf64_External_Dyn *x_dynp_64;
> struct bfd_section *sect;
> - struct target_section *target_section;
>
> if (abfd == NULL)
> return 0;
> @@ -608,14 +607,15 @@ scan_dyntag (const int desired_dyntag, bfd *abfd, CORE_ADDR *ptr,
> if (sect == NULL)
> return 0;
>
> - for (target_section = current_target_sections->sections;
> - target_section < current_target_sections->sections_end;
> - target_section++)
> - if (sect == target_section->the_bfd_section)
> - break;
> - if (target_section < current_target_sections->sections_end)
> - dyn_addr = target_section->addr;
> - else
> + bool found = false;
> + for (target_section &target_section : current_target_sections->sections)
> + if (sect == target_section.the_bfd_section)
> + {
> + dyn_addr = target_section.addr;
> + found = true;
> + break;
> + }
> + if (!found)
> {
> /* ABFD may come from OBJFILE acting only as a symbol file without being
> loaded into the target (see add_symbol_file_command). This case is
> diff --git a/gdb/solib.c b/gdb/solib.c
> index cf5d05e83b2..906e1788c49 100644
> --- a/gdb/solib.c
> +++ b/gdb/solib.c
> @@ -532,7 +532,6 @@ static int
> solib_map_sections (struct so_list *so)
> {
> const struct target_so_ops *ops = solib_ops (target_gdbarch ());
> - struct target_section *p;
>
> gdb::unique_xmalloc_ptr<char> filename (tilde_expand (so->so_name));
> gdb_bfd_ref_ptr abfd (ops->bfd_open (filename.get ()));
> @@ -553,27 +552,29 @@ solib_map_sections (struct so_list *so)
> error (_("Shared library file name is too long."));
> strcpy (so->so_name, bfd_get_filename (so->abfd));
>
> - if (build_section_table (so->abfd, &so->sections, &so->sections_end))
> + if (so->sections == nullptr)
> + so->sections = new target_section_table;
> + if (build_section_table (so->abfd, so->sections))
> {
> error (_("Can't find the file sections in `%s': %s"),
> bfd_get_filename (so->abfd), bfd_errmsg (bfd_get_error ()));
> }
>
> - for (p = so->sections; p < so->sections_end; p++)
> + for (target_section &p : so->sections->sections)
> {
> /* Relocate the section binding addresses as recorded in the shared
> object's file by the base address to which the object was actually
> mapped. */
> - ops->relocate_section_addresses (so, p);
> + ops->relocate_section_addresses (so, &p);
>
> /* If the target didn't provide information about the address
> range of the shared object, assume we want the location of
> the .text section. */
> if (so->addr_low == 0 && so->addr_high == 0
> - && strcmp (p->the_bfd_section->name, ".text") == 0)
> + && strcmp (p.the_bfd_section->name, ".text") == 0)
> {
> - so->addr_low = p->addr;
> - so->addr_high = p->endaddr;
> + so->addr_low = p.addr;
> + so->addr_high = p.endaddr;
> }
> }
>
> @@ -581,7 +582,7 @@ solib_map_sections (struct so_list *so)
> section tables. Do this immediately after mapping the object so
> that later nodes in the list can query this object, as is needed
> in solib-osf.c. */
> - add_target_sections (so, so->sections, so->sections_end);
> + add_target_sections (so, *so->sections);
>
> return 1;
> }
> @@ -600,11 +601,8 @@ clear_so (struct so_list *so)
> {
> const struct target_so_ops *ops = solib_ops (target_gdbarch ());
>
> - if (so->sections)
> - {
> - xfree (so->sections);
> - so->sections = so->sections_end = NULL;
> - }
> + delete so->sections;
> + so->sections = NULL;
>
> gdb_bfd_unref (so->abfd);
> so->abfd = NULL;
> @@ -683,8 +681,7 @@ solib_read_symbols (struct so_list *so, symfile_add_flags flags)
> if (so->objfile == NULL)
> {
> section_addr_info sap
> - = build_section_addr_info_from_section_table (so->sections,
> - so->sections_end);
> + = build_section_addr_info_from_section_table (*so->sections);
> so->objfile = symbol_file_add_from_bfd (so->abfd, so->so_name,
> flags, &sap,
> OBJF_SHARED, NULL);
> @@ -1120,10 +1117,8 @@ bool
> solib_contains_address_p (const struct so_list *const solib,
> CORE_ADDR address)
> {
> - struct target_section *p;
> -
> - for (p = solib->sections; p < solib->sections_end; p++)
> - if (p->addr <= address && address < p->endaddr)
> + for (target_section &p : solib->sections->sections)
> + if (p.addr <= address && address < p.endaddr)
> return true;
>
> return false;
> diff --git a/gdb/solist.h b/gdb/solist.h
> index 0360d342ae8..1de797cc14b 100644
> --- a/gdb/solist.h
> +++ b/gdb/solist.h
> @@ -23,6 +23,7 @@
> /* For domain_enum domain. */
> #include "symtab.h"
> #include "gdb_bfd.h"
> +#include "target-section.h"
>
> /* Base class for target-specific link map information. */
>
> @@ -71,8 +72,7 @@ struct so_list
> the file cannot be found or after the command "nosharedlibrary". */
> struct objfile *objfile;
>
> - struct target_section *sections;
> - struct target_section *sections_end;
> + target_section_table *sections;
>
> /* Record the range of addresses belonging to this shared library.
> There may not be just one (e.g. if two segments are relocated
> diff --git a/gdb/symfile.c b/gdb/symfile.c
> index baed72e936e..f4acec50cca 100644
> --- a/gdb/symfile.c
> +++ b/gdb/symfile.c
> @@ -212,21 +212,18 @@ find_lowest_section (asection *sect, asection **lowest)
> an existing section table. */
>
> section_addr_info
> -build_section_addr_info_from_section_table (const struct target_section *start,
> - const struct target_section *end)
> +build_section_addr_info_from_section_table (const target_section_table &table)
> {
> - const struct target_section *stp;
> -
> section_addr_info sap;
>
> - for (stp = start; stp != end; stp++)
> + for (const target_section &stp : table.sections)
> {
> - struct bfd_section *asect = stp->the_bfd_section;
> + struct bfd_section *asect = stp.the_bfd_section;
> bfd *abfd = asect->owner;
>
> if (bfd_section_flags (asect) & (SEC_ALLOC | SEC_LOAD)
> - && sap.size () < end - start)
> - sap.emplace_back (stp->addr,
> + && sap.size () < table.sections.size ())
> + sap.emplace_back (stp.addr,
> bfd_section_name (asect),
> gdb_bfd_section_index (abfd, asect));
> }
> diff --git a/gdb/symfile.h b/gdb/symfile.h
> index ae29451fc6a..df646f0736f 100644
> --- a/gdb/symfile.h
> +++ b/gdb/symfile.h
> @@ -27,6 +27,7 @@
> #include "objfile-flags.h"
> #include "gdb_bfd.h"
> #include "gdbsupport/function-view.h"
> +#include "target-section.h"
>
> /* Opaque declarations. */
> struct target_section;
> @@ -451,10 +452,7 @@ extern std::string find_separate_debug_file_by_debuglink (struct objfile *);
> existing section table. */
>
> extern section_addr_info
> - build_section_addr_info_from_section_table (const struct target_section
> - *start,
> - const struct target_section
> - *end);
> + build_section_addr_info_from_section_table (const target_section_table &table);
>
> /* Variables */
>
> diff --git a/gdb/target-section.h b/gdb/target-section.h
> index 581bc1dbe9f..8c81f3d79ba 100644
> --- a/gdb/target-section.h
> +++ b/gdb/target-section.h
> @@ -39,12 +39,11 @@ struct target_section
> void *owner;
> };
>
> -/* Holds an array of target sections. Defined by [SECTIONS..SECTIONS_END[. */
> +/* Holds an array of target sections. */
>
> struct target_section_table
> {
> - struct target_section *sections;
> - struct target_section *sections_end;
> + std::vector<struct target_section> sections;
> };
>
> #endif /* GDB_TARGET_SECTION_H */
> diff --git a/gdb/target.c b/gdb/target.c
> index dd78a848cae..f828d3d6cc3 100644
> --- a/gdb/target.c
> +++ b/gdb/target.c
> @@ -823,15 +823,14 @@ struct target_section *
> target_section_by_addr (struct target_ops *target, CORE_ADDR addr)
> {
> struct target_section_table *table = target_get_section_table (target);
> - struct target_section *secp;
>
> if (table == NULL)
> return NULL;
>
> - for (secp = table->sections; secp < table->sections_end; secp++)
> + for (target_section &secp : table->sections)
> {
> - if (addr >= secp->addr && addr < secp->endaddr)
> - return secp;
> + if (addr >= secp.addr && addr < secp.endaddr)
> + return &secp;
> }
> return NULL;
> }
> @@ -978,9 +977,7 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
>
> return section_table_xfer_memory_partial (readbuf, writebuf,
> memaddr, len, xfered_len,
> - table->sections,
> - table->sections_end,
> - match_cb);
> + *table, match_cb);
> }
> }
>
> @@ -997,8 +994,7 @@ memory_xfer_partial_1 (struct target_ops *ops, enum target_object object,
> table = target_get_section_table (ops);
> return section_table_xfer_memory_partial (readbuf, writebuf,
> memaddr, len, xfered_len,
> - table->sections,
> - table->sections_end);
> + *table);
> }
> }
>
>
More information about the Gdb-patches
mailing list