"rtld_db_dlactivity",
"_rtld_debug_state",
- /* On the 64-bit PowerPC, the linker symbol with the same name as
- the C function points to a function descriptor, not to the entry
- point. The linker symbol whose name is the C function name
- prefixed with a '.' points to the function's entry point. So
- when we look through this table, we ignore symbols that point
- into the data section (thus skipping the descriptor's symbol),
- and eventually try this one, giving us the real entry point
- address. */
- "._dl_debug_state",
-
NULL
};
don't adjust the base offset in the latter case, although
odds are that, if things really changed, debugging won't
quite work. */
- if ((l_addr & align) == 0 && ((dynaddr - l_dynaddr) & align) == 0)
+ if ((l_addr & align) == ((l_dynaddr - dynaddr) & align))
{
l_addr = l_dynaddr - dynaddr;
{
struct link_map_offsets *lmo = svr4_fetch_link_map_offsets ();
+ /* Assume that everything is a library if the dynamic loader was loaded
+ late by a static executable. */
+ if (bfd_get_section_by_name (exec_bfd, ".dynamic") == NULL)
+ return 0;
+
return extract_typed_address (so->lm_info->lm + lmo->l_prev_offset,
builtin_type_void_data_ptr) == 0;
}
static CORE_ADDR debug_base; /* Base of dynamic linker structures */
-static CORE_ADDR breakpoint_addr; /* Address where end bkpt is set */
/* Validity flag for debug_loader_offset. */
static int debug_loader_offset_p;
static int match_main (char *);
-static CORE_ADDR bfd_lookup_symbol (bfd *, char *, flagword);
+static CORE_ADDR bfd_lookup_symbol (bfd *, char *);
/*
SYNOPSIS
- CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+ CORE_ADDR bfd_lookup_symbol (bfd *abfd, char *symname)
DESCRIPTION
An expensive way to lookup the value of a single symbol for
bfd's that are only temporary anyway. This is used by the
shared library support to find the address of the debugger
- interface structures in the shared library.
+ notification routine in the shared library.
- If SECT_FLAGS is non-zero, only match symbols in sections whose
- flags include all those in SECT_FLAGS.
+ The returned symbol may be in a code or data section; functions
+ will normally be in a code section, but may be in a data section
+ if this architecture uses function descriptors.
Note that 0 is specifically allowed as an error return (no
such symbol).
*/
static CORE_ADDR
-bfd_lookup_symbol (bfd *abfd, char *symname, flagword sect_flags)
+bfd_lookup_symbol (bfd *abfd, char *symname)
{
long storage_needed;
asymbol *sym;
{
sym = *symbol_table++;
if (strcmp (sym->name, symname) == 0
- && (sym->section->flags & sect_flags) == sect_flags)
+ && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
{
- /* Bfd symbols are section relative. */
+ /* BFD symbols are section relative. */
symaddr = sym->value + sym->section->vma;
break;
}
sym = *symbol_table++;
if (strcmp (sym->name, symname) == 0
- && (sym->section->flags & sect_flags) == sect_flags)
+ && (sym->section->flags & (SEC_CODE | SEC_DATA)) != 0)
{
- /* Bfd symbols are section relative. */
+ /* BFD symbols are section relative. */
symaddr = sym->value + sym->section->vma;
break;
}
return symaddr;
}
+/* Scan for DYNTAG in .dynamic section of ABFD. If DYNTAG is found 1 is
+ returned and the corresponding PTR is set. */
+
+static int
+scan_dyntag (int dyntag, bfd *abfd, CORE_ADDR *ptr)
+{
+ int arch_size, step, sect_size;
+ long dyn_tag;
+ CORE_ADDR dyn_ptr, dyn_addr;
+ gdb_byte *bufend, *bufstart, *buf;
+ Elf32_External_Dyn *x_dynp_32;
+ Elf64_External_Dyn *x_dynp_64;
+ struct bfd_section *sect;
+
+ if (abfd == NULL)
+ return 0;
+ arch_size = bfd_get_arch_size (abfd);
+ if (arch_size == -1)
+ return 0;
+
+ /* Find the start address of the .dynamic section. */
+ sect = bfd_get_section_by_name (abfd, ".dynamic");
+ if (sect == NULL)
+ return 0;
+ dyn_addr = bfd_section_vma (abfd, sect);
+
+ /* Read in .dynamic from the BFD. We will get the actual value
+ from memory later. */
+ sect_size = bfd_section_size (abfd, sect);
+ buf = bufstart = alloca (sect_size);
+ if (!bfd_get_section_contents (abfd, sect,
+ buf, 0, sect_size))
+ return 0;
+
+ /* Iterate over BUF and scan for DYNTAG. If found, set PTR and return. */
+ step = (arch_size == 32) ? sizeof (Elf32_External_Dyn)
+ : sizeof (Elf64_External_Dyn);
+ for (bufend = buf + sect_size;
+ buf < bufend;
+ buf += step)
+ {
+ if (arch_size == 32)
+ {
+ x_dynp_32 = (Elf32_External_Dyn *) buf;
+ dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_tag);
+ dyn_ptr = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp_32->d_un.d_ptr);
+ }
+ else
+ {
+ x_dynp_64 = (Elf64_External_Dyn *) buf;
+ dyn_tag = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_tag);
+ dyn_ptr = bfd_h_get_64 (abfd, (bfd_byte *) x_dynp_64->d_un.d_ptr);
+ }
+ if (dyn_tag == DT_NULL)
+ return 0;
+ if (dyn_tag == dyntag)
+ {
+ /* If requested, try to read the runtime value of this .dynamic
+ entry. */
+ if (ptr)
+ {
+ gdb_byte ptr_buf[8];
+ CORE_ADDR ptr_addr;
+
+ ptr_addr = dyn_addr + (buf - bufstart) + arch_size / 8;
+ if (target_read_memory (ptr_addr, ptr_buf, arch_size / 8) == 0)
+ dyn_ptr = extract_typed_address (ptr_buf,
+ builtin_type_void_data_ptr);
+ *ptr = dyn_ptr;
+ }
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+
/*
LOCAL FUNCTION
static CORE_ADDR
elf_locate_base (void)
{
- struct bfd_section *dyninfo_sect;
- int dyninfo_sect_size;
- CORE_ADDR dyninfo_addr;
- gdb_byte *buf;
- gdb_byte *bufend;
- int arch_size;
-
- /* Find the start address of the .dynamic section. */
- dyninfo_sect = bfd_get_section_by_name (exec_bfd, ".dynamic");
- if (dyninfo_sect == NULL)
- return 0;
- dyninfo_addr = bfd_section_vma (exec_bfd, dyninfo_sect);
-
- /* Read in .dynamic section, silently ignore errors. */
- dyninfo_sect_size = bfd_section_size (exec_bfd, dyninfo_sect);
- buf = alloca (dyninfo_sect_size);
- if (target_read_memory (dyninfo_addr, buf, dyninfo_sect_size))
- return 0;
-
- /* Find the DT_DEBUG entry in the the .dynamic section.
- For mips elf we look for DT_MIPS_RLD_MAP, mips elf apparently has
- no DT_DEBUG entries. */
-
- arch_size = bfd_get_arch_size (exec_bfd);
- if (arch_size == -1) /* failure */
- return 0;
-
- if (arch_size == 32)
- { /* 32-bit elf */
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf32_External_Dyn))
- {
- Elf32_External_Dyn *x_dynp = (Elf32_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
+ struct minimal_symbol *msymbol;
+ CORE_ADDR dyn_ptr;
- dyn_tag = bfd_h_get_32 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
- {
- dyn_ptr = bfd_h_get_32 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
- }
- else if (dyn_tag == DT_MIPS_RLD_MAP)
- {
- gdb_byte *pbuf;
- int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
-
- pbuf = alloca (pbuf_size);
- /* DT_MIPS_RLD_MAP contains a pointer to the address
- of the dynamic link structure. */
- dyn_ptr = bfd_h_get_32 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
- return 0;
- return extract_typed_address (pbuf, builtin_type_void_data_ptr);
- }
- }
- }
- else /* 64-bit elf */
+ /* Look for DT_MIPS_RLD_MAP first. MIPS executables use this
+ instead of DT_DEBUG, although they sometimes contain an unused
+ DT_DEBUG. */
+ if (scan_dyntag (DT_MIPS_RLD_MAP, exec_bfd, &dyn_ptr))
{
- for (bufend = buf + dyninfo_sect_size;
- buf < bufend;
- buf += sizeof (Elf64_External_Dyn))
- {
- Elf64_External_Dyn *x_dynp = (Elf64_External_Dyn *) buf;
- long dyn_tag;
- CORE_ADDR dyn_ptr;
-
- dyn_tag = bfd_h_get_64 (exec_bfd, (bfd_byte *) x_dynp->d_tag);
- if (dyn_tag == DT_NULL)
- break;
- else if (dyn_tag == DT_DEBUG)
- {
- dyn_ptr = bfd_h_get_64 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- return dyn_ptr;
- }
- else if (dyn_tag == DT_MIPS_RLD_MAP)
- {
- gdb_byte *pbuf;
- int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
-
- pbuf = alloca (pbuf_size);
- /* DT_MIPS_RLD_MAP contains a pointer to the address
- of the dynamic link structure. */
- dyn_ptr = bfd_h_get_64 (exec_bfd,
- (bfd_byte *) x_dynp->d_un.d_ptr);
- if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
- return 0;
- return extract_typed_address (pbuf, builtin_type_void_data_ptr);
- }
- }
+ gdb_byte *pbuf;
+ int pbuf_size = TYPE_LENGTH (builtin_type_void_data_ptr);
+ pbuf = alloca (pbuf_size);
+ /* DT_MIPS_RLD_MAP contains a pointer to the address
+ of the dynamic link structure. */
+ if (target_read_memory (dyn_ptr, pbuf, pbuf_size))
+ return 0;
+ return extract_typed_address (pbuf, builtin_type_void_data_ptr);
}
+ /* Find DT_DEBUG. */
+ if (scan_dyntag (DT_DEBUG, exec_bfd, &dyn_ptr))
+ return dyn_ptr;
+
+ /* This may be a static executable. Look for the symbol
+ conventionally named _r_debug, as a last resort. */
+ msymbol = lookup_minimal_symbol ("_r_debug", NULL, symfile_objfile);
+ if (msymbol != NULL)
+ return SYMBOL_VALUE_ADDRESS (msymbol);
+
/* DT_DEBUG entry not found. */
return 0;
}
/* Now fetch the filename from target memory. */
target_read_string (l_name, &filename, SO_NAME_MAX_PATH_SIZE - 1, &errcode);
+ make_cleanup (xfree, filename);
if (errcode)
{
return 0;
}
- make_cleanup (xfree, filename);
/* Have a pathname: read the symbol file. */
symbol_file_add_main (filename, from_tty);
{
strncpy (new->so_name, buffer, SO_NAME_MAX_PATH_SIZE - 1);
new->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
- xfree (buffer);
strcpy (new->so_original_name, new->so_name);
}
+ xfree (buffer);
/* If this entry has no name, or its name matches the name
for the main executable, don't include it in the list. */
/* Is this the linkmap for the file we want? */
/* If the file is not a shared library and has no name,
we are sure it is the main executable, so we return that. */
- if ((buffer && strcmp (buffer, objfile->name) == 0)
- || (!(objfile->flags & OBJF_SHARED) && (strcmp (buffer, "") == 0)))
+
+ if (buffer
+ && ((strcmp (buffer, objfile->name) == 0)
+ || (!(objfile->flags & OBJF_SHARED)
+ && (strcmp (buffer, "") == 0))))
{
do_cleanups (old_chain);
return lm;
static CORE_ADDR interp_plt_sect_low;
static CORE_ADDR interp_plt_sect_high;
-static int
+int
svr4_in_dynsym_resolve_code (CORE_ADDR pc)
{
return ((pc >= interp_text_sect_low && pc < interp_text_sect_high)
static int
enable_break (void)
{
- int success = 0;
-
#ifdef BKPT_AT_SYMBOL
struct minimal_symbol *msymbol;
/* On a running target, we can get the dynamic linker's base
address from the shared library table. */
- solib_add (NULL, 0, NULL, auto_solib_add);
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
so = master_so_list ();
while (so)
{
debug_loader_name = xstrdup (buf);
debug_loader_offset_p = 1;
debug_loader_offset = load_addr;
- solib_add (NULL, 0, NULL, auto_solib_add);
+ solib_add (NULL, 0, ¤t_target, auto_solib_add);
}
/* Record the relocated start and end address of the dynamic linker
/* Now try to set a breakpoint in the dynamic linker. */
for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
- /* On ABI's that use function descriptors, there are usually
- two linker symbols associated with each C function: one
- pointing at the actual entry point of the machine code,
- and one pointing at the function's descriptor. The
- latter symbol has the same name as the C function.
-
- What we're looking for here is the machine code entry
- point, so we are only interested in symbols in code
- sections. */
- sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep, SEC_CODE);
+ sym_addr = bfd_lookup_symbol (tmp_bfd, *bkpt_namep);
if (sym_addr != 0)
break;
}
+ if (sym_addr != 0)
+ /* Convert 'sym_addr' from a function pointer to an address.
+ Because we pass tmp_bfd_target instead of the current
+ target, this will always produce an unrelocated value. */
+ sym_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+ sym_addr,
+ tmp_bfd_target);
+
/* We're done with both the temporary bfd and target. Remember,
closing the target closes the underlying bfd. */
target_close (tmp_bfd_target, 0);
/* For whatever reason we couldn't set a breakpoint in the dynamic
linker. Warn and drop into the old code. */
bkpt_at_symbol:
+ xfree (tmp_pathname);
warning (_("Unable to find dynamic linker breakpoint function.\n"
"GDB will be unable to debug shared library initializers\n"
"and track explicitly loaded dynamic code."));
}
- /* Scan through the list of symbols, trying to look up the symbol and
- set a breakpoint there. Terminate loop when we/if we succeed. */
+ /* Scan through the lists of symbols, trying to look up the symbol and
+ set a breakpoint there. Terminate loop when we/if we succeed. */
- breakpoint_addr = 0;
- for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ for (bkpt_namep = solib_break_names; *bkpt_namep != NULL; bkpt_namep++)
{
msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
}
}
- /* Nothing good happened. */
- success = 0;
-
+ for (bkpt_namep = bkpt_names; *bkpt_namep != NULL; bkpt_namep++)
+ {
+ msymbol = lookup_minimal_symbol (*bkpt_namep, NULL, symfile_objfile);
+ if ((msymbol != NULL) && (SYMBOL_VALUE_ADDRESS (msymbol) != 0))
+ {
+ create_solib_event_breakpoint (SYMBOL_VALUE_ADDRESS (msymbol));
+ return 1;
+ }
+ }
#endif /* BKPT_AT_SYMBOL */
- return (success);
+ return 0;
}
/*
svr4_relocate_main_executable ();
if (!svr4_have_link_map_offsets ())
- {
- warning (_("no shared library support for this OS / ABI"));
- return;
-
- }
+ return;
if (!enable_break ())
- {
- warning (_("shared library handler failed to enable breakpoint"));
- return;
- }
+ return;
#if defined(_SCO_DS)
/* SCO needs the loop below, other systems should be using the
natural pointer/address correspondence. (For example, on the MIPS,
converting a 32-bit pointer to a 64-bit CORE_ADDR requires you to
sign-extend the value. There, simply truncating the bits above
- TARGET_PTR_BIT, as we do below, is no good.) This should probably
+ gdbarch_ptr_bit, as we do below, is no good.) This should probably
be a new gdbarch method or something. */
static CORE_ADDR
svr4_truncate_ptr (CORE_ADDR addr)
{
- if (TARGET_PTR_BIT == sizeof (CORE_ADDR) * 8)
+ if (gdbarch_ptr_bit (current_gdbarch) == sizeof (CORE_ADDR) * 8)
/* We don't need to truncate anything, and the bit twiddling below
will fail due to overflow problems. */
return addr;
else
- return addr & (((CORE_ADDR) 1 << TARGET_PTR_BIT) - 1);
+ return addr & (((CORE_ADDR) 1 << gdbarch_ptr_bit (current_gdbarch)) - 1);
}
}
\f
-static struct target_so_ops svr4_so_ops;
+struct target_so_ops svr4_so_ops;
+
+/* Lookup global symbol for ELF DSOs linked with -Bsymbolic. Those DSOs have a
+ different rule for symbol lookup. The lookup begins here in the DSO, not in
+ the main executable. */
+
+static struct symbol *
+elf_lookup_lib_symbol (const struct objfile *objfile,
+ const char *name,
+ const char *linkage_name,
+ const domain_enum domain, struct symtab **symtab)
+{
+ if (objfile->obfd == NULL
+ || scan_dyntag (DT_SYMBOLIC, objfile->obfd, NULL) != 1)
+ return NULL;
+
+ return lookup_global_symbol_from_objfile
+ (objfile, name, linkage_name, domain, symtab);
+}
extern initialize_file_ftype _initialize_svr4_solib; /* -Wmissing-prototypes */
svr4_so_ops.current_sos = svr4_current_sos;
svr4_so_ops.open_symbol_file_object = open_symbol_file_object;
svr4_so_ops.in_dynsym_resolve_code = svr4_in_dynsym_resolve_code;
+ svr4_so_ops.lookup_lib_global_symbol = elf_lookup_lib_symbol;
/* FIXME: Don't do this here. *_gdbarch_init() should set so_ops. */
current_target_so_ops = &svr4_so_ops;