Browse Source
solib-osf.o. * config/alpha/alpha-osf1.mh (NATDEPFILES): Replace osfsolib.o with solib-osf.o and solib.o. * config/alpha/alpha-osf2.mh: Likewise. * config/alpha/alpha-osf3.mh: Likewise. * solib-osf.c: New file, renamed and largely rewritten from osfsolib.c.dberlin-typesystem-branch
Nicholas Duffek
26 years ago
6 changed files with 631 additions and 7 deletions
@ -0,0 +1,611 @@ |
|||
/* Handle OSF/1, Digital UNIX, and Tru64 shared libraries
|
|||
for GDB, the GNU Debugger. |
|||
Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001 |
|||
Free Software Foundation, Inc. |
|||
|
|||
This file is part of GDB. |
|||
|
|||
This program is free software; you can redistribute it and/or modify |
|||
it under the terms of the GNU General Public License as published by |
|||
the Free Software Foundation; either version 2 of the License, or |
|||
(at your option) any later version. |
|||
|
|||
This program is distributed in the hope that it will be useful, |
|||
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|||
GNU General Public License for more details. |
|||
|
|||
You should have received a copy of the GNU General Public License |
|||
along with this program; if not, write to the Free Software |
|||
Foundation, Inc., 59 Temple Place - Suite 330, |
|||
Boston, MA 02111-1307, USA. */ |
|||
|
|||
/* When handling shared libraries, GDB has to find out the pathnames
|
|||
of all shared libraries that are currently loaded (to read in their |
|||
symbols) and where the shared libraries are loaded in memory |
|||
(to relocate them properly from their prelinked addresses to the |
|||
current load address). |
|||
|
|||
Under OSF/1 there are two possibilities to get at this information: |
|||
|
|||
1) Peek around in the runtime loader structures. |
|||
These are not documented, and they are not defined in the system |
|||
header files. The definitions below were obtained by experimentation, |
|||
but they seem stable enough. |
|||
|
|||
2) Use the libxproc.a library, which contains the equivalent ldr_* |
|||
routines. The library is documented in Tru64 5.x, but as of 5.1, it |
|||
only allows a process to examine itself. On earlier versions, it |
|||
may require that the GDB executable be dynamically linked and that |
|||
NAT_CLIBS include -lxproc -Wl,-expect_unresolved,ldr_process_context |
|||
for GDB and all applications that are using libgdb. |
|||
|
|||
We will use the peeking approach until libxproc.a works for other |
|||
processes. */ |
|||
|
|||
#include "defs.h" |
|||
|
|||
#include <sys/types.h> |
|||
#include <signal.h> |
|||
#include "gdb_string.h" |
|||
|
|||
#include "bfd.h" |
|||
#include "symtab.h" |
|||
#include "symfile.h" |
|||
#include "objfiles.h" |
|||
#include "target.h" |
|||
#include "inferior.h" |
|||
#include "solist.h" |
|||
|
|||
#ifdef USE_LDR_ROUTINES |
|||
# include <loader.h> |
|||
#endif |
|||
|
|||
#ifndef USE_LDR_ROUTINES |
|||
/* Definition of runtime loader structures, found by experimentation. */ |
|||
#define RLD_CONTEXT_ADDRESS 0x3ffc0000000 |
|||
|
|||
/* Per-module information structure referenced by ldr_context_t.head. */ |
|||
|
|||
typedef struct |
|||
{ |
|||
CORE_ADDR next; |
|||
CORE_ADDR previous; |
|||
CORE_ADDR unknown1; |
|||
CORE_ADDR module_name; |
|||
CORE_ADDR modinfo_addr; /* used by next_link_map_member() to detect
|
|||
the end of the shared module list */ |
|||
long module_id; |
|||
CORE_ADDR unknown2; |
|||
CORE_ADDR unknown3; |
|||
long region_count; |
|||
CORE_ADDR regioninfo_addr; |
|||
} |
|||
ldr_module_info_t; |
|||
|
|||
/* Per-region structure referenced by ldr_module_info_t.regioninfo_addr. */ |
|||
|
|||
typedef struct |
|||
{ |
|||
long unknown1; |
|||
CORE_ADDR regionname_addr; |
|||
long protection; |
|||
CORE_ADDR vaddr; |
|||
CORE_ADDR mapaddr; |
|||
long size; |
|||
long unknown2[5]; |
|||
} |
|||
ldr_region_info_t; |
|||
|
|||
/* Structure at RLD_CONTEXT_ADDRESS specifying the start and finish addresses
|
|||
of the shared module list. */ |
|||
|
|||
typedef struct |
|||
{ |
|||
CORE_ADDR unknown1; |
|||
CORE_ADDR unknown2; |
|||
CORE_ADDR head; |
|||
CORE_ADDR tail; |
|||
} |
|||
ldr_context_t; |
|||
#endif /* !USE_LDR_ROUTINES */ |
|||
|
|||
/* Per-section information, stored in struct lm_info.secs. */ |
|||
|
|||
struct lm_sec |
|||
{ |
|||
CORE_ADDR offset; /* difference between default and actual
|
|||
virtual addresses of section .name */ |
|||
CORE_ADDR nameaddr; /* address in inferior of section name */ |
|||
const char *name; /* name of section, null if not fetched */ |
|||
}; |
|||
|
|||
/* Per-module information, stored in struct so_list.lm_info. */ |
|||
|
|||
struct lm_info |
|||
{ |
|||
int isloader; /* whether the module is /sbin/loader */ |
|||
int nsecs; /* length of .secs */ |
|||
struct lm_sec secs[1]; /* variable-length array of sections, sorted
|
|||
by name */ |
|||
}; |
|||
|
|||
/* Context for iterating through the inferior's shared module list. */ |
|||
|
|||
struct read_map_ctxt |
|||
{ |
|||
#ifdef USE_LDR_ROUTINES |
|||
ldr_process_t proc; |
|||
ldr_module_t next; |
|||
#else |
|||
CORE_ADDR next; /* next element in module list */ |
|||
CORE_ADDR tail; /* last element in module list */ |
|||
#endif |
|||
}; |
|||
|
|||
/* Forward declaration for this module's autoinit function. */ |
|||
|
|||
extern void _initialize_osf_solib (void); |
|||
|
|||
#ifdef USE_LDR_ROUTINES |
|||
# if 0 |
|||
/* This routine is intended to be called by ldr_* routines to read memory from
|
|||
the current target. Usage: |
|||
|
|||
ldr_process = ldr_core_process (); |
|||
ldr_set_core_reader (ldr_read_memory); |
|||
ldr_xdetach (ldr_process); |
|||
ldr_xattach (ldr_process); |
|||
|
|||
ldr_core_process() and ldr_read_memory() are neither documented nor |
|||
declared in system header files. They work with OSF/1 2.x, and they might |
|||
work with later versions as well. */ |
|||
|
|||
static int |
|||
ldr_read_memory (CORE_ADDR memaddr, char *myaddr, int len, int readstring) |
|||
{ |
|||
int result; |
|||
char *buffer; |
|||
|
|||
if (readstring) |
|||
{ |
|||
target_read_string (memaddr, &buffer, len, &result); |
|||
if (result == 0) |
|||
strcpy (myaddr, buffer); |
|||
xfree (buffer); |
|||
} |
|||
else |
|||
result = target_read_memory (memaddr, myaddr, len); |
|||
|
|||
if (result != 0) |
|||
result = -result; |
|||
return result; |
|||
} |
|||
# endif /* 0 */ |
|||
#endif /* USE_LDR_ROUTINES */ |
|||
|
|||
/* Comparison for qsort() and bsearch(): return -1, 0, or 1 according to
|
|||
whether lm_sec *P1's name is lexically less than, equal to, or greater |
|||
than that of *P2. */ |
|||
|
|||
static int |
|||
lm_sec_cmp (const void *p1, const void *p2) |
|||
{ |
|||
const struct lm_sec *lms1 = p1, *lms2 = p2; |
|||
return strcmp (lms1->name, lms2->name); |
|||
} |
|||
|
|||
/* Sort LMI->secs so that osf_relocate_section_addresses() can binary-search
|
|||
it. */ |
|||
|
|||
static void |
|||
lm_secs_sort (struct lm_info *lmi) |
|||
{ |
|||
qsort (lmi->secs, lmi->nsecs, sizeof *lmi->secs, lm_sec_cmp); |
|||
} |
|||
|
|||
/* Populate name fields of LMI->secs. */ |
|||
|
|||
static void |
|||
fetch_sec_names (struct lm_info *lmi) |
|||
{ |
|||
#ifndef USE_LDR_ROUTINES |
|||
int i, errcode; |
|||
struct lm_sec *lms; |
|||
char *name; |
|||
|
|||
for (i = 0; i < lmi->nsecs; i++) |
|||
{ |
|||
lms = lmi->secs + i; |
|||
target_read_string (lms->nameaddr, &name, PATH_MAX, &errcode); |
|||
if (errcode != 0) |
|||
{ |
|||
warning ("unable to read shared sec name at 0x%lx", lms->nameaddr); |
|||
name = xstrdup (""); |
|||
} |
|||
lms->name = name; |
|||
} |
|||
lm_secs_sort (lmi); |
|||
#endif |
|||
} |
|||
|
|||
/* target_so_ops callback. Adjust SEC's addresses after it's been mapped into
|
|||
the process. */ |
|||
|
|||
static void |
|||
osf_relocate_section_addresses (struct so_list *so, |
|||
struct section_table *sec) |
|||
{ |
|||
struct lm_info *lmi; |
|||
struct lm_sec lms_key, *lms; |
|||
|
|||
/* Fetch SO's section names if we haven't done so already. */ |
|||
lmi = so->lm_info; |
|||
if (lmi->nsecs && !lmi->secs[0].name) |
|||
fetch_sec_names (lmi); |
|||
|
|||
/* Binary-search for offset information corresponding to SEC. */ |
|||
lms_key.name = sec->the_bfd_section->name; |
|||
lms = bsearch (&lms_key, lmi->secs, lmi->nsecs, sizeof *lms, lm_sec_cmp); |
|||
if (lms) |
|||
{ |
|||
sec->addr += lms->offset; |
|||
sec->endaddr += lms->offset; |
|||
} |
|||
} |
|||
|
|||
/* target_so_ops callback. Free parts of SO allocated by this file. */ |
|||
|
|||
static void |
|||
osf_free_so (struct so_list *so) |
|||
{ |
|||
int i; |
|||
const char *name; |
|||
|
|||
for (i = 0; i < so->lm_info->nsecs; i++) |
|||
{ |
|||
name = so->lm_info->secs[i].name; |
|||
if (name) |
|||
xfree ((void *) name); |
|||
} |
|||
xfree (so->lm_info); |
|||
} |
|||
|
|||
/* target_so_ops callback. Discard information accumulated by this file and
|
|||
not freed by osf_free_so(). */ |
|||
|
|||
static void |
|||
osf_clear_solib (void) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
/* target_so_ops callback. Prepare to handle shared libraries after the
|
|||
inferior process has been created but before it's executed any |
|||
instructions. |
|||
|
|||
For a statically bound executable, the inferior's first instruction is the |
|||
one at "_start", or a similar text label. No further processing is needed |
|||
in that case. |
|||
|
|||
For a dynamically bound executable, this first instruction is somewhere |
|||
in the rld, and the actual user executable is not yet mapped in. |
|||
We continue the inferior again, rld then maps in the actual user |
|||
executable and any needed shared libraries and then sends |
|||
itself a SIGTRAP. |
|||
|
|||
At that point we discover the names of all shared libraries and |
|||
read their symbols in. |
|||
|
|||
FIXME |
|||
|
|||
This code does not properly handle hitting breakpoints which the |
|||
user might have set in the rld itself. Proper handling would have |
|||
to check if the SIGTRAP happened due to a kill call. |
|||
|
|||
Also, what if child has exit()ed? Must exit loop somehow. */ |
|||
|
|||
static void |
|||
osf_solib_create_inferior_hook (void) |
|||
{ |
|||
/* Nothing to do for statically bound executables. */ |
|||
|
|||
if (symfile_objfile == NULL |
|||
|| symfile_objfile->obfd == NULL |
|||
|| ((bfd_get_file_flags (symfile_objfile->obfd) & DYNAMIC) == 0)) |
|||
return; |
|||
|
|||
/* Now run the target. It will eventually get a SIGTRAP, at
|
|||
which point all of the libraries will have been mapped in and we |
|||
can go groveling around in the rld structures to find |
|||
out what we need to know about them. */ |
|||
|
|||
clear_proceed_status (); |
|||
stop_soon_quietly = 1; |
|||
stop_signal = TARGET_SIGNAL_0; |
|||
do |
|||
{ |
|||
target_resume (minus_one_ptid, 0, stop_signal); |
|||
wait_for_inferior (); |
|||
} |
|||
while (stop_signal != TARGET_SIGNAL_TRAP); |
|||
|
|||
/* solib_add will call reinit_frame_cache.
|
|||
But we are stopped in the runtime loader and we do not have symbols |
|||
for the runtime loader. So heuristic_proc_start will be called |
|||
and will put out an annoying warning. |
|||
Delaying the resetting of stop_soon_quietly until after symbol loading |
|||
suppresses the warning. */ |
|||
if (auto_solib_add) |
|||
solib_add ((char *) 0, 0, (struct target_ops *) 0); |
|||
stop_soon_quietly = 0; |
|||
|
|||
/* Enable breakpoints disabled (unnecessarily) by clear_solib(). */ |
|||
re_enable_breakpoints_in_shlibs (); |
|||
} |
|||
|
|||
/* target_so_ops callback. Do additional symbol handling, lookup, etc. after
|
|||
symbols for a shared object have been loaded. */ |
|||
|
|||
static void |
|||
osf_special_symbol_handling (void) |
|||
{ |
|||
return; |
|||
} |
|||
|
|||
/* Initialize CTXT in preparation for iterating through the inferior's module
|
|||
list using read_map(). Return success. */ |
|||
|
|||
static int |
|||
open_map (struct read_map_ctxt *ctxt) |
|||
{ |
|||
#ifdef USE_LDR_ROUTINES |
|||
ctxt->proc = ldr_my_process (); |
|||
if (ldr_xattach (ctxt->proc) != 0) |
|||
return 0; |
|||
ctxt->next = LDR_NULL_MODULE; |
|||
#else |
|||
CORE_ADDR ldr_context_addr, prev, next; |
|||
ldr_context_t ldr_context; |
|||
|
|||
if (target_read_memory ((CORE_ADDR) RLD_CONTEXT_ADDRESS, |
|||
(char *) &ldr_context_addr, |
|||
sizeof (CORE_ADDR)) != 0) |
|||
return 0; |
|||
if (target_read_memory (ldr_context_addr, |
|||
(char *) &ldr_context, |
|||
sizeof (ldr_context_t)) != 0) |
|||
return 0; |
|||
ctxt->next = ldr_context.head; |
|||
ctxt->tail = ldr_context.tail; |
|||
#endif |
|||
return 1; |
|||
} |
|||
|
|||
/* Initialize SO to have module NAME, /sbin/loader indicator ISLOADR, and
|
|||
space for NSECS sections. */ |
|||
|
|||
static void |
|||
init_so (struct so_list *so, char *name, int isloader, int nsecs) |
|||
{ |
|||
int namelen, i; |
|||
|
|||
/* solib.c requires various fields to be initialized to 0. */ |
|||
memset (so, 0, sizeof *so); |
|||
|
|||
/* Copy the name. */ |
|||
namelen = strlen (name); |
|||
if (namelen >= SO_NAME_MAX_PATH_SIZE) |
|||
namelen = SO_NAME_MAX_PATH_SIZE - 1; |
|||
|
|||
memcpy (so->so_original_name, name, namelen); |
|||
so->so_original_name[namelen] = '\0'; |
|||
memcpy (so->so_name, so->so_original_name, namelen + 1); |
|||
|
|||
/* Allocate section space. */ |
|||
so->lm_info = xmalloc ((unsigned) &(((struct lm_info *)0)->secs) + |
|||
nsecs * sizeof *so->lm_info); |
|||
so->lm_info->isloader = isloader; |
|||
so->lm_info->nsecs = nsecs; |
|||
for (i = 0; i < nsecs; i++) |
|||
so->lm_info->secs[i].name = NULL; |
|||
} |
|||
|
|||
/* Initialize SO's section SECIDX with name address NAMEADDR, name string
|
|||
NAME, default virtual address VADDR, and actual virtual address |
|||
MAPADDR. */ |
|||
|
|||
static void |
|||
init_sec (struct so_list *so, int secidx, CORE_ADDR nameaddr, |
|||
const char *name, CORE_ADDR vaddr, CORE_ADDR mapaddr) |
|||
{ |
|||
struct lm_sec *lms; |
|||
|
|||
lms = so->lm_info->secs + secidx; |
|||
lms->nameaddr = nameaddr; |
|||
lms->name = name; |
|||
lms->offset = mapaddr - vaddr; |
|||
} |
|||
|
|||
/* If there are more elements starting at CTXT in inferior's module list,
|
|||
store the next element in SO, advance CTXT to the next element, and return |
|||
1, else return 0. */ |
|||
|
|||
static int |
|||
read_map (struct read_map_ctxt *ctxt, struct so_list *so) |
|||
{ |
|||
ldr_module_info_t minf; |
|||
ldr_region_info_t rinf; |
|||
|
|||
#ifdef USE_LDR_ROUTINES |
|||
size_t size; |
|||
ldr_region_t i; |
|||
|
|||
/* Retrieve the next element. */ |
|||
if (ldr_next_module (ctxt->proc, &ctxt->next) != 0) |
|||
return 0; |
|||
if (ctxt->next == LDR_NULL_MODULE) |
|||
return 0; |
|||
if (ldr_inq_module (ctxt->proc, ctxt->next, &minf, sizeof minf, &size) != 0) |
|||
return 0; |
|||
|
|||
/* Initialize the module name and section count. */ |
|||
init_so (so, minf.lmi_name, 0, minf.lmi_nregion); |
|||
|
|||
/* Retrieve section names and offsets. */ |
|||
for (i = 0; i < minf.lmi_nregion; i++) |
|||
{ |
|||
if (ldr_inq_region (ctxt->proc, ctxt->next, i, &rinf, |
|||
sizeof rinf, &size) != 0) |
|||
goto err; |
|||
init_sec (so, (int) i, 0, xstrdup (rinf.lri_name), |
|||
(CORE_ADDR) rinf.lri_vaddr, (CORE_ADDR) rinf.lri_mapaddr); |
|||
} |
|||
lm_secs_sort (so->lm_info); |
|||
#else |
|||
char *name; |
|||
int errcode, i; |
|||
|
|||
/* Retrieve the next element. */ |
|||
if (!ctxt->next) |
|||
return 0; |
|||
if (target_read_memory (ctxt->next, (char *) &minf, sizeof minf) != 0) |
|||
return 0; |
|||
if (ctxt->next == ctxt->tail) |
|||
ctxt->next = 0; |
|||
else |
|||
ctxt->next = minf.next; |
|||
|
|||
/* Initialize the module name and section count. */ |
|||
target_read_string (minf.module_name, &name, PATH_MAX, &errcode); |
|||
if (errcode != 0) |
|||
return 0; |
|||
init_so (so, name, !minf.modinfo_addr, minf.region_count); |
|||
xfree (name); |
|||
|
|||
/* Retrieve section names and offsets. */ |
|||
for (i = 0; i < minf.region_count; i++) |
|||
{ |
|||
if (target_read_memory (minf.regioninfo_addr + i * sizeof rinf, |
|||
(char *) &rinf, sizeof rinf) != 0) |
|||
goto err; |
|||
init_sec (so, i, rinf.regionname_addr, NULL, rinf.vaddr, rinf.mapaddr); |
|||
} |
|||
#endif /* !USE_LDR_ROUTINES */ |
|||
return 1; |
|||
|
|||
err: |
|||
osf_free_so (so); |
|||
return 0; |
|||
} |
|||
|
|||
/* Free resources allocated by open_map (CTXT). */ |
|||
|
|||
static void |
|||
close_map (struct read_map_ctxt *ctxt) |
|||
{ |
|||
#ifdef USE_LDR_ROUTINES |
|||
ldr_xdetach (ctxt->proc); |
|||
#endif |
|||
} |
|||
|
|||
/* target_so_ops callback. Return a list of shared objects currently loaded
|
|||
in the inferior. */ |
|||
|
|||
static struct so_list * |
|||
osf_current_sos (void) |
|||
{ |
|||
struct so_list *head = NULL, *tail, *newtail, so; |
|||
struct read_map_ctxt ctxt; |
|||
int skipped_main; |
|||
|
|||
if (!open_map (&ctxt)) |
|||
return NULL; |
|||
|
|||
/* Read subsequent elements. */ |
|||
for (skipped_main = 0;;) |
|||
{ |
|||
if (!read_map (&ctxt, &so)) |
|||
break; |
|||
|
|||
/* Skip the main program module, which is first in the list after
|
|||
/sbin/loader. */ |
|||
if (!so.lm_info->isloader && !skipped_main) |
|||
{ |
|||
osf_free_so (&so); |
|||
skipped_main = 1; |
|||
continue; |
|||
} |
|||
|
|||
newtail = xmalloc (sizeof *newtail); |
|||
if (!head) |
|||
head = newtail; |
|||
else |
|||
tail->next = newtail; |
|||
tail = newtail; |
|||
|
|||
memcpy (tail, &so, sizeof so); |
|||
tail->next = NULL; |
|||
} |
|||
|
|||
done: |
|||
close_map (&ctxt); |
|||
return head; |
|||
} |
|||
|
|||
/* target_so_ops callback. Attempt to locate and open the main symbol
|
|||
file. */ |
|||
|
|||
static int |
|||
osf_open_symbol_file_object (void *from_ttyp) |
|||
{ |
|||
struct read_map_ctxt ctxt; |
|||
struct so_list so; |
|||
int found; |
|||
|
|||
if (symfile_objfile) |
|||
if (!query ("Attempt to reload symbols from process? ")) |
|||
return 0; |
|||
|
|||
/* The first module after /sbin/loader is the main program. */ |
|||
if (!open_map (&ctxt)) |
|||
return 0; |
|||
for (found = 0; !found;) |
|||
{ |
|||
if (!read_map (&ctxt, &so)) |
|||
break; |
|||
found = !so.lm_info->isloader; |
|||
osf_free_so (&so); |
|||
} |
|||
close_map (&ctxt); |
|||
|
|||
if (found) |
|||
symbol_file_add_main (so.so_name, *(int *) from_ttyp); |
|||
return found; |
|||
} |
|||
|
|||
/* target_so_ops callback. Return whether PC is in the dynamic linker. */ |
|||
|
|||
static int |
|||
osf_in_dynsym_resolve_code (CORE_ADDR pc) |
|||
{ |
|||
return 0; |
|||
} |
|||
|
|||
static struct target_so_ops osf_so_ops; |
|||
|
|||
void |
|||
_initialize_osf_solib (void) |
|||
{ |
|||
osf_so_ops.relocate_section_addresses = osf_relocate_section_addresses; |
|||
osf_so_ops.free_so = osf_free_so; |
|||
osf_so_ops.clear_solib = osf_clear_solib; |
|||
osf_so_ops.solib_create_inferior_hook = osf_solib_create_inferior_hook; |
|||
osf_so_ops.special_symbol_handling = osf_special_symbol_handling; |
|||
osf_so_ops.current_sos = osf_current_sos; |
|||
osf_so_ops.open_symbol_file_object = osf_open_symbol_file_object; |
|||
osf_so_ops.in_dynsym_resolve_code = osf_in_dynsym_resolve_code; |
|||
|
|||
/* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */ |
|||
current_target_so_ops = &osf_so_ops; |
|||
} |
|||
Loading…
Reference in new issue