static void
exec_close_1 (void)
{
using_exec_ops = 0;
{
struct program_space *ss;
struct cleanup *old_chain;
old_chain = save_current_program_space ();
ALL_PSPACES (ss)
{
set_current_program_space (ss);
/* Delete all target sections. */
resize_section_table
(current_target_sections,
-resize_section_table (current_target_sections, 0));
exec_close ();
}
do_cleanups (old_chain);
}
}
static void
exec_close_1 (int quitting)
{
int need_symtab_cleanup = 0;
struct vmap *vp, *nxt;
using_exec_ops = 0;
for (nxt = vmap; nxt != NULL;)
{
vp = nxt;
nxt = vp->nxt;
/* if there is an objfile associated with this bfd,
free_objfile() will do proper cleanup of objfile *and* bfd. */
if (vp->objfile)
{
free_objfile (vp->objfile);
need_symtab_cleanup = 1;
}
else if (vp->bfd != exec_bfd)
/* FIXME-leak: We should be freeing vp->name too, I think. */
gdb_bfd_close_or_warn (vp->bfd);
xfree (vp);
}
vmap = NULL;
{
struct program_space *ss;
struct cleanup *old_chain;
old_chain = save_current_program_space ();
ALL_PSPACES (ss)
{
set_current_program_space (ss);
/* Delete all target sections. */
resize_section_table
(current_target_sections,
-resize_section_table (current_target_sections, 0));
exec_close ();
}
do_cleanups (old_chain);
}
}
void
add_target_sections (void *owner,
struct target_section *sections,
struct target_section *sections_end)
{
int count;
struct target_section_table *table = current_target_sections;
count = sections_end - sections;
if (count > 0)
{
int space = resize_section_table (table, count);
int i;
for (i = 0; i < count; ++i)
{
table->sections[space + i] = sections[i];
table->sections[space + i].owner = owner;
}
/* If these are the first file sections we can provide memory
from, push the file_stratum target. */
if (!using_exec_ops)
{
using_exec_ops = 1;
push_target (&exec_ops);
}
}
}
void
add_target_sections (struct target_section *sections,
struct target_section *sections_end)
{
int count;
struct target_section_table *table = current_target_sections;
count = sections_end - sections;
if (count > 0)
{
int space = resize_section_table (table, count);
memcpy (table->sections + space,
sections, count * sizeof (sections[0]));
/* If these are the first file sections we can provide memory
from, push the file_stratum target. */
if (!using_exec_ops)
{
using_exec_ops = 1;
push_target (&exec_ops);
}
}
}
struct target_section *
deprecated_core_resize_section_table (int num_added)
{
int old_count;
old_count = resize_section_table (core_data, num_added);
return core_data->sections + old_count;
}
static void
exec_close_1 (int quitting)
{
struct vmap *vp, *nxt;
using_exec_ops = 0;
for (nxt = vmap; nxt != NULL;)
{
vp = nxt;
nxt = vp->nxt;
if (vp->objfile)
free_objfile (vp->objfile);
gdb_bfd_unref (vp->bfd);
xfree (vp);
}
vmap = NULL;
{
struct program_space *ss;
struct cleanup *old_chain;
old_chain = save_current_program_space ();
ALL_PSPACES (ss)
{
set_current_program_space (ss);
/* Delete all target sections. */
resize_section_table
(current_target_sections,
-resize_section_table (current_target_sections, 0));
exec_close ();
}
do_cleanups (old_chain);
}
}
void
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;
/* Compute the number of sections to add. */
ALL_OBJFILE_OSECTIONS (objfile, osect)
{
if (bfd_get_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_get_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++;
}
}
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)
{
int old_count;
old_count = resize_section_table (table, dest - src);
/* If we don't have any more sections to read memory from,
remove the file_stratum target from the stack. */
if (old_count + (dest - src) == 0)
{
struct program_space *pspace;
ALL_PSPACES (pspace)
if (pspace->target_sections.sections
!= pspace->target_sections.sections_end)
return;
unpush_target (&exec_ops);
}
}
