static void
vmap_ldinfo (LdInfo *ldi)
{
struct stat ii, vi;
struct vmap *vp;
int got_one, retried;
int got_exec_file = 0;
uint next;
int arch64 = ARCH64 ();
/* For each *ldi, see if we have a corresponding *vp.
If so, update the mapping, and symbol table.
If not, add an entry and symbol table. */
do
{
char *name = LDI_FILENAME (ldi, arch64);
char *memb = name + strlen (name) + 1;
int fd = LDI_FD (ldi, arch64);
retried = 0;
if (fstat (fd, &ii) < 0)
{
/* The kernel sets ld_info to -1, if the process is still using the
object, and the object is removed. Keep the symbol info for the
removed object and issue a warning. */
warning (_("%s (fd=%d) has disappeared, keeping its symbols"),
name, fd);
continue;
}
retry:
for (got_one = 0, vp = vmap; vp; vp = vp->nxt)
{
struct objfile *objfile;
/* First try to find a `vp', which is the same as in ldinfo.
If not the same, just continue and grep the next `vp'. If same,
relocate its tstart, tend, dstart, dend values. If no such `vp'
found, get out of this for loop, add this ldi entry as a new vmap
(add_vmap) and come back, find its `vp' and so on... */
/* The filenames are not always sufficient to match on. */
if ((name[0] == '/' && strcmp (name, vp->name) != 0)
|| (memb[0] && strcmp (memb, vp->member) != 0))
continue;
/* See if we are referring to the same file.
We have to check objfile->obfd, symfile.c:reread_symbols might
have updated the obfd after a change. */
objfile = vp->objfile == NULL ? symfile_objfile : vp->objfile;
if (objfile == NULL
|| objfile->obfd == NULL
|| bfd_stat (objfile->obfd, &vi) < 0)
{
warning (_("Unable to stat %s, keeping its symbols"), name);
continue;
}
if (ii.st_dev != vi.st_dev || ii.st_ino != vi.st_ino)
continue;
if (!retried)
close (fd);
++got_one;
/* Found a corresponding VMAP. Remap! */
vmap_secs (vp, ldi, arch64);
/* The objfile is only NULL for the exec file. */
if (vp->objfile == NULL)
got_exec_file = 1;
/* relocate symbol table(s). */
vmap_symtab (vp);
/* Announce new object files. Doing this after symbol relocation
makes aix-thread.c's job easier. */
if (vp->objfile)
observer_notify_new_objfile (vp->objfile);
/* There may be more, so we don't break out of the loop. */
}
/* if there was no matching *vp, we must perforce create the sucker(s) */
if (!got_one && !retried)
{
add_vmap (ldi);
++retried;
goto retry;
}
}
while ((next = LDI_NEXT (ldi, arch64))
&& (ldi = (void *) (next + (char *) ldi)));
/* If we don't find the symfile_objfile anywhere in the ldinfo, it
is unlikely that the symbol file is relocated to the proper
address. And we might have attached to a process which is
running a different copy of the same executable. */
if (symfile_objfile != NULL && !got_exec_file)
{
warning (_("Symbol file %s\nis not mapped; discarding it.\n\
If in fact that file has symbols which the mapped files listed by\n\
\"info files\" lack, you can load symbols with the \"symbol-file\" or\n\
\"add-symbol-file\" commands (note that you must take care of relocating\n\
symbols to the proper address)."),
symfile_objfile->name);
free_objfile (symfile_objfile);
gdb_assert (symfile_objfile == NULL);
}
static struct vmap *
add_vmap (LdInfo *ldi)
{
bfd *abfd, *last;
char *mem, *objname, *filename;
struct objfile *obj;
struct vmap *vp;
int fd;
ARCH64_DECL (arch64);
/* This ldi structure was allocated using alloca() in
xcoff_relocate_symtab(). Now we need to have persistent object
and member names, so we should save them. */
filename = LDI_FILENAME (ldi, arch64);
mem = filename + strlen (filename) + 1;
mem = xstrdup (mem);
objname = xstrdup (filename);
fd = LDI_FD (ldi, arch64);
if (fd < 0)
/* Note that this opens it once for every member; a possible
enhancement would be to only open it once for every object. */
abfd = bfd_openr (objname, gnutarget);
else
abfd = bfd_fdopenr (objname, gnutarget, fd);
if (!abfd)
{
warning (_("Could not open `%s' as an executable file: %s"),
objname, bfd_errmsg (bfd_get_error ()));
return NULL;
}
/* make sure we have an object file */
if (bfd_check_format (abfd, bfd_object))
vp = map_vmap (abfd, 0);
else if (bfd_check_format (abfd, bfd_archive))
{
last = 0;
/* FIXME??? am I tossing BFDs? bfd? */
while ((last = bfd_openr_next_archived_file (abfd, last)))
if (strcmp (mem, last->filename) == 0)
break;
if (!last)
{
warning (_("\"%s\": member \"%s\" missing."), objname, mem);
bfd_close (abfd);
return NULL;
}
if (!bfd_check_format (last, bfd_object))
{
warning (_("\"%s\": member \"%s\" not in executable format: %s."),
objname, mem, bfd_errmsg (bfd_get_error ()));
bfd_close (last);
bfd_close (abfd);
return NULL;
}
vp = map_vmap (last, abfd);
}
else
{
warning (_("\"%s\": not in executable format: %s."),
objname, bfd_errmsg (bfd_get_error ()));
bfd_close (abfd);
return NULL;
}
obj = allocate_objfile (vp->bfd, 0);
vp->objfile = obj;
/* Always add symbols for the main objfile. */
if (vp == vmap || auto_solib_add)
vmap_add_symbols (vp);
return vp;
}
void
xcoff_relocate_core (struct target_ops *target)
{
struct bfd_section *ldinfo_sec;
int offset = 0;
LdInfo *ldi;
struct vmap *vp;
int arch64 = ARCH64 ();
/* Size of a struct ld_info except for the variable-length filename. */
int nonfilesz = (int)LDI_FILENAME ((LdInfo *)0, arch64);
/* Allocated size of buffer. */
int buffer_size = nonfilesz;
char *buffer = xmalloc (buffer_size);
struct cleanup *old = make_cleanup (free_current_contents, &buffer);
ldinfo_sec = bfd_get_section_by_name (core_bfd, ".ldinfo");
if (ldinfo_sec == NULL)
{
bfd_err:
fprintf_filtered (gdb_stderr, "Couldn't get ldinfo from core file: %s\n",
bfd_errmsg (bfd_get_error ()));
do_cleanups (old);
return;
}
do
{
int i;
int names_found = 0;
/* Read in everything but the name. */
if (bfd_get_section_contents (core_bfd, ldinfo_sec, buffer,
offset, nonfilesz) == 0)
goto bfd_err;
/* Now the name. */
i = nonfilesz;
do
{
if (i == buffer_size)
{
buffer_size *= 2;
buffer = xrealloc (buffer, buffer_size);
}
if (bfd_get_section_contents (core_bfd, ldinfo_sec, &buffer[i],
offset + i, 1) == 0)
goto bfd_err;
if (buffer[i++] == '\0')
++names_found;
}
while (names_found < 2);
ldi = (LdInfo *) buffer;
/* Can't use a file descriptor from the core file; need to open it. */
if (arch64)
ldi->l64.ldinfo_fd = -1;
else
ldi->l32.ldinfo_fd = -1;
/* The first ldinfo is for the exec file, allocated elsewhere. */
if (offset == 0 && vmap != NULL)
vp = vmap;
else
vp = add_vmap (ldi);
/* Process next shared library upon error. */
offset += LDI_NEXT (ldi, arch64);
if (vp == NULL)
continue;
vmap_secs (vp, ldi, arch64);
/* Unless this is the exec file,
add our sections to the section table for the core target. */
if (vp != vmap)
{
struct section_table *stp;
target_resize_to_sections (target, 2);
stp = target->to_sections_end - 2;
stp->bfd = vp->bfd;
stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".text");
stp->addr = vp->tstart;
stp->endaddr = vp->tend;
stp++;
stp->bfd = vp->bfd;
stp->the_bfd_section = bfd_get_section_by_name (stp->bfd, ".data");
stp->addr = vp->dstart;
stp->endaddr = vp->dend;
}
vmap_symtab (vp);
if (deprecated_target_new_objfile_hook && vp != vmap && vp->objfile)
deprecated_target_new_objfile_hook (vp->objfile);
}
while (LDI_NEXT (ldi, arch64) != 0);
vmap_exec ();
breakpoint_re_set ();
do_cleanups (old);
}
static void
rs6000_xfer_shared_library (LdInfo *ldi, struct obstack *obstack)
{
const int arch64 = ARCH64 ();
const char *archive_name = LDI_FILENAME (ldi, arch64);
const char *member_name = archive_name + strlen (archive_name) + 1;
CORE_ADDR text_addr, data_addr;
ULONGEST text_size, data_size;
char *p;
if (arch64)
{
text_addr = ldi->l64.ldinfo_textorg;
text_size = ldi->l64.ldinfo_textsize;
data_addr = ldi->l64.ldinfo_dataorg;
data_size = ldi->l64.ldinfo_datasize;
}
else
{
/* The text and data addresses are defined as pointers.
To avoid sign-extending their value in the assignments
below, we cast their value to unsigned long first. */
text_addr = (unsigned long) ldi->l32.ldinfo_textorg;
text_size = ldi->l32.ldinfo_textsize;
data_addr = (unsigned long) ldi->l32.ldinfo_dataorg;
data_size = ldi->l32.ldinfo_datasize;
}
obstack_grow_str (obstack, "<library name=\"");
p = xml_escape_text (archive_name);
obstack_grow_str (obstack, p);
xfree (p);
obstack_grow_str (obstack, "\"");
if (member_name[0] != '\0')
{
obstack_grow_str (obstack, " member=\"");
p = xml_escape_text (member_name);
obstack_grow_str (obstack, p);
xfree (p);
obstack_grow_str (obstack, "\"");
}
obstack_grow_str (obstack, " text_addr=\"");
obstack_grow_str (obstack, core_addr_to_string (text_addr));
obstack_grow_str (obstack, "\"");
obstack_grow_str (obstack, " text_size=\"");
obstack_grow_str (obstack, pulongest (text_size));
obstack_grow_str (obstack, "\"");
obstack_grow_str (obstack, " data_addr=\"");
obstack_grow_str (obstack, core_addr_to_string (data_addr));
obstack_grow_str (obstack, "\"");
obstack_grow_str (obstack, " data_size=\"");
obstack_grow_str (obstack, pulongest (data_size));
obstack_grow_str (obstack, "\"");
obstack_grow_str (obstack, "></library>");
}
static struct vmap *
add_vmap (LdInfo *ldi)
{
bfd *abfd, *last;
char *mem, *filename;
struct objfile *obj;
struct vmap *vp;
int fd;
ARCH64_DECL (arch64);
/* This ldi structure was allocated using alloca() in
xcoff_relocate_symtab(). Now we need to have persistent object
and member names, so we should save them. */
filename = LDI_FILENAME (ldi, arch64);
mem = filename + strlen (filename) + 1;
mem = xstrdup (mem);
fd = LDI_FD (ldi, arch64);
abfd = gdb_bfd_open (filename, gnutarget, fd < 0 ? -1 : fd);
if (!abfd)
{
warning (_("Could not open `%s' as an executable file: %s"),
filename, bfd_errmsg (bfd_get_error ()));
return NULL;
}
/* Make sure we have an object file. */
if (bfd_check_format (abfd, bfd_object))
vp = map_vmap (abfd, 0);
else if (bfd_check_format (abfd, bfd_archive))
{
last = gdb_bfd_openr_next_archived_file (abfd, NULL);
while (last != NULL)
{
bfd *next;
if (strcmp (mem, last->filename) == 0)
break;
next = gdb_bfd_openr_next_archived_file (abfd, last);
gdb_bfd_unref (last);
last = next;
}
if (!last)
{
warning (_("\"%s\": member \"%s\" missing."), filename, mem);
gdb_bfd_unref (abfd);
return NULL;
}
if (!bfd_check_format (last, bfd_object))
{
warning (_("\"%s\": member \"%s\" not in executable format: %s."),
filename, mem, bfd_errmsg (bfd_get_error ()));
gdb_bfd_unref (last);
gdb_bfd_unref (abfd);
return NULL;
}
vp = map_vmap (last, abfd);
/* map_vmap acquired a reference to LAST, so we can release
ours. */
gdb_bfd_unref (last);
}
else
{
warning (_("\"%s\": not in executable format: %s."),
filename, bfd_errmsg (bfd_get_error ()));
gdb_bfd_unref (abfd);
return NULL;
}
obj = allocate_objfile (vp->bfd, 0);
vp->objfile = obj;
/* Always add symbols for the main objfile. */
if (vp == vmap || auto_solib_add)
vmap_add_symbols (vp);
/* Anything needing a reference to ABFD has already acquired it, so
release our local reference. */
gdb_bfd_unref (abfd);
return vp;
}
