mirror of
https://github.com/darlinghq/darling-gdb.git
synced 2024-12-05 10:57:57 +00:00
2fe3b329f6
are in the .plt section. * minsyms.c (lookup_solib_trampoline_symbol_by_pc, find_solib_trampoline_target): New functions for handling stepping into -g compiled shared libraries. * symtab.h (lookup_solib_trampoline_symbol_by_pc, find_solib_trampoline_target): Add prototypes. * config/tm-sunos.h (IN_SOLIB_TRAMPOLINE, SKIP_TRAMPOLINE_CODE): Define to handle stepping into -g compiled shared libraries. * config/tm-sysv4.h (SKIP_TRAMPOLINE_CODE): Define to handle stepping into -g compiled shared libraries. * configure.in: Add mips-*-sysv4* support. * config/mips/mipsv4.mh, config/mips/mipsv4.mt, config/mips/tm-mipsv4.h, config/mips/xm-mipsv4.h, mipsv4-nat.c: New files for MIPS SVR4 support. * Makefile.in: Update for new mipsv4 files. * alpha-tdep.c (heuristic_proc_desc, find_proc_desc): Use read_next_frame_reg to obtain the frame relative stack pointer. * mips-tdep.c (heuristic_proc_desc): Use read_next_frame_reg to obtain the frame relative stack pointer. * mdebugread.c (parse_partial_symbols, psymtab_to_symtab1): Handle stStatic and stStaticProc symbols in stabs-in-ecoff output by entering them into the minimal symbol table. * printcmd.c (print_scalar_formatted): Do not try to unpack to a long for float formats. * solib.c: Include "elf/mips.h" only if DT_MIPS_RLD_MAP does not get defined in <link.h>. * solib.c (solib_add): Add shared library sections to the section table of the target before adding the symbols. * partial-stab.h: Relocate static and global functions. * dbxread.c (read_dbx_symtab): Remove unused variable end_of_text_address. Relocate text_addr when passing it to end_psymtab. For Alpha OSF/1 targets, enable gdb to set breakpoints in shared library functions before the executable is run. Retrieve dynamic symbols from stripped executables. * mipsread.c (read_alphacoff_dynamic_symtab): New function. * mipsread.c (mipscoff_symfile_read): Use it. Issue warning message if no debugging symbols were found. * alpha-tdep.c (alpha_skip_prologue): Silently return the unaltered pc if memory at the pc is not accessible and GDB_TARGET_HAS_SHARED_LIBS is defined. * config/alpha/nm-alpha.h (GDB_TARGET_HAS_SHARED_LIBS): Define, OSF/1 has shared libraries.
464 lines
14 KiB
C
464 lines
14 KiB
C
/* Read a symbol table in MIPS' format (Third-Eye).
|
|
Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994
|
|
Free Software Foundation, Inc.
|
|
Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work
|
|
by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
|
|
|
|
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
/* Read symbols from an ECOFF file. Most of the work is done in
|
|
mdebugread.c. */
|
|
|
|
#include "defs.h"
|
|
#include <string.h>
|
|
#include "bfd.h"
|
|
#include "symtab.h"
|
|
#include "symfile.h"
|
|
#include "objfiles.h"
|
|
#include "buildsym.h"
|
|
#include "stabsread.h"
|
|
#include "gdb-stabs.h"
|
|
|
|
#include "coff/sym.h"
|
|
#include "coff/internal.h"
|
|
#include "coff/ecoff.h"
|
|
#include "libcoff.h" /* Private BFD COFF information. */
|
|
#include "libecoff.h" /* Private BFD ECOFF information. */
|
|
#include "elf/common.h"
|
|
#include "elf/mips.h"
|
|
|
|
static void
|
|
mipscoff_new_init PARAMS ((struct objfile *));
|
|
|
|
static void
|
|
mipscoff_symfile_init PARAMS ((struct objfile *));
|
|
|
|
static void
|
|
mipscoff_symfile_read PARAMS ((struct objfile *, struct section_offsets *,
|
|
int));
|
|
|
|
static void
|
|
mipscoff_symfile_finish PARAMS ((struct objfile *));
|
|
|
|
static struct section_offsets *
|
|
mipscoff_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
|
|
|
|
static void
|
|
read_alphacoff_dynamic_symtab PARAMS ((struct section_offsets *,
|
|
struct objfile *objfile));
|
|
|
|
/* Initialize anything that needs initializing when a completely new
|
|
symbol file is specified (not just adding some symbols from another
|
|
file, e.g. a shared library). */
|
|
|
|
extern CORE_ADDR sigtramp_address;
|
|
|
|
static void
|
|
mipscoff_new_init (ignore)
|
|
struct objfile *ignore;
|
|
{
|
|
sigtramp_address = 0;
|
|
stabsread_new_init ();
|
|
buildsym_new_init ();
|
|
}
|
|
|
|
/* Initialize to read a symbol file (nothing to do). */
|
|
|
|
static void
|
|
mipscoff_symfile_init (objfile)
|
|
struct objfile *objfile;
|
|
{
|
|
}
|
|
|
|
/* Read a symbol file from a file. */
|
|
|
|
static void
|
|
mipscoff_symfile_read (objfile, section_offsets, mainline)
|
|
struct objfile *objfile;
|
|
struct section_offsets *section_offsets;
|
|
int mainline;
|
|
{
|
|
bfd *abfd = objfile->obfd;
|
|
struct cleanup * back_to;
|
|
|
|
init_minimal_symbol_collection ();
|
|
back_to = make_cleanup (discard_minimal_symbols, 0);
|
|
|
|
/* Now that the executable file is positioned at symbol table,
|
|
process it and define symbols accordingly. */
|
|
|
|
if (ecoff_slurp_symbolic_info (abfd) == false)
|
|
error ("Error reading symbol table: %s", bfd_errmsg (bfd_get_error ()));
|
|
|
|
mdebug_build_psymtabs (objfile, &ecoff_backend (abfd)->debug_swap,
|
|
&ecoff_data (abfd)->debug_info, section_offsets);
|
|
|
|
/* Add the dynamic symbols if we are reading the main symbol table. */
|
|
|
|
if (mainline)
|
|
read_alphacoff_dynamic_symtab (section_offsets, objfile);
|
|
|
|
if (!have_partial_symbols ())
|
|
{
|
|
wrap_here ("");
|
|
printf_filtered ("(no debugging symbols found)...");
|
|
wrap_here ("");
|
|
}
|
|
|
|
/* Install any minimal symbols that have been collected as the current
|
|
minimal symbols for this objfile. */
|
|
|
|
install_minimal_symbols (objfile);
|
|
|
|
do_cleanups (back_to);
|
|
}
|
|
|
|
/* Perform any local cleanups required when we are done with a
|
|
particular objfile. */
|
|
|
|
static void
|
|
mipscoff_symfile_finish (objfile)
|
|
struct objfile *objfile;
|
|
{
|
|
}
|
|
|
|
/* Fake up identical offsets for all sections. */
|
|
|
|
static struct section_offsets *
|
|
mipscoff_symfile_offsets (objfile, addr)
|
|
struct objfile *objfile;
|
|
CORE_ADDR addr;
|
|
{
|
|
struct section_offsets *section_offsets;
|
|
int i;
|
|
|
|
objfile->num_sections = SECT_OFF_MAX;
|
|
section_offsets = ((struct section_offsets *)
|
|
obstack_alloc (&objfile->psymbol_obstack,
|
|
(sizeof (struct section_offsets)
|
|
+ (sizeof (section_offsets->offsets)
|
|
* (SECT_OFF_MAX - 1)))));
|
|
|
|
for (i = 0; i < SECT_OFF_MAX; i++)
|
|
ANOFFSET (section_offsets, i) = addr;
|
|
|
|
return section_offsets;
|
|
}
|
|
|
|
/* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
|
|
standard coff section. The ELF format for the symbols differs from
|
|
the format defined in elf/external.h. It seems that a normal ELF 32 bit
|
|
format is used, and the representation only changes because longs are
|
|
64 bit on the alpha. In addition, the handling of text/data section
|
|
indices for symbols is different from the ELF ABI.
|
|
As the BFD linker currently does not support dynamic linking on the alpha,
|
|
there seems to be no reason to pollute BFD with another mixture of object
|
|
file formats for now. */
|
|
|
|
/* Format of an alpha external ELF symbol. */
|
|
|
|
typedef struct {
|
|
unsigned char st_name[4]; /* Symbol name, index in string tbl */
|
|
unsigned char st_pad[4]; /* Pad to long word boundary */
|
|
unsigned char st_value[8]; /* Value of the symbol */
|
|
unsigned char st_size[4]; /* Associated symbol size */
|
|
unsigned char st_info[1]; /* Type and binding attributes */
|
|
unsigned char st_other[1]; /* No defined meaning, 0 */
|
|
unsigned char st_shndx[2]; /* Associated section index */
|
|
} Elfalpha_External_Sym;
|
|
|
|
/* Format of an alpha external ELF dynamic info structure. */
|
|
|
|
typedef struct {
|
|
unsigned char d_tag[4]; /* Tag */
|
|
unsigned char d_pad[4]; /* Pad to long word boundary */
|
|
union {
|
|
unsigned char d_ptr[8]; /* Pointer value */
|
|
unsigned char d_val[4]; /* Integer value */
|
|
} d_un;
|
|
} Elfalpha_External_Dyn;
|
|
|
|
/* Struct to obtain the section pointers for alpha dynamic symbol info. */
|
|
|
|
struct alphacoff_dynsecinfo {
|
|
asection *sym_sect; /* Section pointer for .dynsym section */
|
|
asection *str_sect; /* Section pointer for .dynstr section */
|
|
asection *dyninfo_sect; /* Section pointer for .dynamic section */
|
|
asection *got_sect; /* Section pointer for .got section */
|
|
};
|
|
|
|
static void
|
|
alphacoff_locate_sections PARAMS ((bfd *, asection *, void *));
|
|
|
|
/* We are called once per section from read_alphacoff_dynamic_symtab.
|
|
We need to examine each section we are passed, check to see
|
|
if it is something we are interested in processing, and
|
|
if so, stash away some access information for the section. */
|
|
|
|
static void
|
|
alphacoff_locate_sections (ignore_abfd, sectp, sip)
|
|
bfd *ignore_abfd;
|
|
asection *sectp;
|
|
PTR sip;
|
|
{
|
|
register struct alphacoff_dynsecinfo *si;
|
|
|
|
si = (struct alphacoff_dynsecinfo *) sip;
|
|
|
|
if (STREQ (sectp->name, ".dynsym"))
|
|
{
|
|
si->sym_sect = sectp;
|
|
}
|
|
else if (STREQ (sectp->name, ".dynstr"))
|
|
{
|
|
si->str_sect = sectp;
|
|
}
|
|
else if (STREQ (sectp->name, ".dynamic"))
|
|
{
|
|
si->dyninfo_sect = sectp;
|
|
}
|
|
else if (STREQ (sectp->name, ".got"))
|
|
{
|
|
si->got_sect = sectp;
|
|
}
|
|
}
|
|
|
|
/* Scan an alpha dynamic symbol table for symbols of interest and
|
|
add them to the minimal symbol table. */
|
|
|
|
static void
|
|
read_alphacoff_dynamic_symtab (section_offsets, objfile)
|
|
struct section_offsets *section_offsets;
|
|
struct objfile *objfile;
|
|
{
|
|
bfd *abfd = objfile->obfd;
|
|
struct alphacoff_dynsecinfo si;
|
|
char *sym_secptr;
|
|
char *str_secptr;
|
|
char *dyninfo_secptr;
|
|
char *got_secptr;
|
|
bfd_size_type sym_secsize;
|
|
bfd_size_type str_secsize;
|
|
bfd_size_type dyninfo_secsize;
|
|
bfd_size_type got_secsize;
|
|
int sym_count;
|
|
int i;
|
|
int stripped;
|
|
Elfalpha_External_Sym *x_symp;
|
|
char *dyninfo_p;
|
|
char *dyninfo_end;
|
|
int got_entry_size = 8;
|
|
int dt_mips_local_gotno = -1;
|
|
int dt_mips_gotsym = -1;
|
|
|
|
|
|
/* We currently only know how to handle alpha dynamic symbols. */
|
|
if (bfd_get_arch (abfd) != bfd_arch_alpha)
|
|
return;
|
|
|
|
/* Locate the dynamic symbols sections and read them in. */
|
|
memset ((char *) &si, 0, sizeof (si));
|
|
bfd_map_over_sections (abfd, alphacoff_locate_sections, (PTR) &si);
|
|
if (si.sym_sect == NULL
|
|
|| si.str_sect == NULL
|
|
|| si.dyninfo_sect == NULL
|
|
|| si.got_sect == NULL)
|
|
return;
|
|
|
|
sym_secsize = bfd_get_section_size_before_reloc (si.sym_sect);
|
|
str_secsize = bfd_get_section_size_before_reloc (si.str_sect);
|
|
dyninfo_secsize = bfd_get_section_size_before_reloc (si.dyninfo_sect);
|
|
got_secsize = bfd_get_section_size_before_reloc (si.got_sect);
|
|
sym_secptr = alloca (sym_secsize);
|
|
str_secptr = alloca (str_secsize);
|
|
dyninfo_secptr = alloca (dyninfo_secsize);
|
|
got_secptr = alloca (got_secsize);
|
|
|
|
if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
|
|
(file_ptr)0, sym_secsize))
|
|
return;
|
|
if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
|
|
(file_ptr)0, str_secsize))
|
|
return;
|
|
if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
|
|
(file_ptr)0, dyninfo_secsize))
|
|
return;
|
|
if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
|
|
(file_ptr)0, got_secsize))
|
|
return;
|
|
|
|
/* Find the number of local GOT entries and the index for the
|
|
the first dynamic symbol in the GOT. */
|
|
for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize;
|
|
dyninfo_p < dyninfo_end;
|
|
dyninfo_p += sizeof (Elfalpha_External_Dyn))
|
|
{
|
|
Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *)dyninfo_p;
|
|
long dyn_tag;
|
|
|
|
dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
|
|
if (dyn_tag == DT_NULL)
|
|
break;
|
|
else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
|
|
{
|
|
dt_mips_local_gotno = bfd_h_get_32 (abfd,
|
|
(bfd_byte *) x_dynp->d_un.d_val);
|
|
}
|
|
else if (dyn_tag == DT_MIPS_GOTSYM)
|
|
{
|
|
dt_mips_gotsym = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
|
|
}
|
|
}
|
|
if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
|
|
return;
|
|
|
|
/* Scan all dynamic symbols and enter them into the minimal symbol table
|
|
if appropriate. */
|
|
sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
|
|
stripped = (bfd_get_symcount (abfd) == 0);
|
|
|
|
/* Skip first symbol, which is a null dummy. */
|
|
for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
|
|
i < sym_count;
|
|
i++, x_symp++)
|
|
{
|
|
unsigned long strx;
|
|
char *name;
|
|
bfd_vma sym_value;
|
|
unsigned char sym_info;
|
|
unsigned int sym_shndx;
|
|
int isglobal;
|
|
enum minimal_symbol_type ms_type;
|
|
|
|
strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
|
|
if (strx >= str_secsize)
|
|
continue;
|
|
name = str_secptr + strx;
|
|
if (*name == '\0' || *name == '.')
|
|
continue;
|
|
|
|
sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
|
|
sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
|
|
sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
|
|
isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
|
|
|
|
if (sym_shndx == SHN_UNDEF)
|
|
{
|
|
/* Handle undefined functions which are defined in a shared
|
|
library. */
|
|
if (ELF_ST_TYPE (sym_info) != STT_FUNC
|
|
|| ELF_ST_BIND (sym_info) != STB_GLOBAL)
|
|
continue;
|
|
|
|
ms_type = mst_solib_trampoline;
|
|
|
|
/* If sym_value is nonzero, it points to the shared library
|
|
trampoline entry, which is what we are looking for.
|
|
|
|
If sym_value is zero, then we have to get the GOT entry
|
|
for the symbol.
|
|
If the GOT entry is nonzero, it represents the quickstart
|
|
address of the function and we use that as the symbol value.
|
|
|
|
If the GOT entry is zero, the function address has to be resolved
|
|
by the runtime loader before the executable is started.
|
|
We are unable to find any meaningful address for these
|
|
functions in the executable file, so we skip them. */
|
|
if (sym_value == 0)
|
|
{
|
|
int got_entry_offset =
|
|
(i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
|
|
|
|
if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
|
|
continue;
|
|
sym_value =
|
|
bfd_h_get_64 (abfd,
|
|
(bfd_byte *) (got_secptr + got_entry_offset));
|
|
if (sym_value == 0)
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Symbols defined in the executable itself. We only care about
|
|
them if this is a stripped executable, otherwise they have
|
|
been retrieved from the normal symbol table already. */
|
|
if (!stripped)
|
|
continue;
|
|
|
|
if (sym_shndx == SHN_MIPS_TEXT)
|
|
{
|
|
if (isglobal)
|
|
ms_type = mst_text;
|
|
else
|
|
ms_type = mst_file_text;
|
|
sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
|
|
}
|
|
else if (sym_shndx == SHN_MIPS_DATA)
|
|
{
|
|
if (isglobal)
|
|
ms_type = mst_data;
|
|
else
|
|
ms_type = mst_file_data;
|
|
sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
|
|
}
|
|
else if (sym_shndx == SHN_MIPS_ACOMMON)
|
|
{
|
|
if (isglobal)
|
|
ms_type = mst_bss;
|
|
else
|
|
ms_type = mst_file_bss;
|
|
sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
|
|
}
|
|
else if (sym_shndx == SHN_ABS)
|
|
{
|
|
ms_type = mst_abs;
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
prim_record_minimal_symbol (obsavestring (name,
|
|
strlen (name),
|
|
&objfile -> symbol_obstack),
|
|
sym_value,
|
|
ms_type,
|
|
objfile);
|
|
}
|
|
}
|
|
|
|
/* Initialization */
|
|
|
|
static struct sym_fns ecoff_sym_fns =
|
|
{
|
|
bfd_target_ecoff_flavour,
|
|
mipscoff_new_init, /* sym_new_init: init anything gbl to entire symtab */
|
|
mipscoff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
|
|
mipscoff_symfile_read, /* sym_read: read a symbol file into symtab */
|
|
mipscoff_symfile_finish, /* sym_finish: finished with file, cleanup */
|
|
mipscoff_symfile_offsets, /* sym_offsets: dummy FIXME til implem sym reloc */
|
|
NULL /* next: pointer to next struct sym_fns */
|
|
};
|
|
|
|
void
|
|
_initialize_mipsread ()
|
|
{
|
|
add_symtab_fns (&ecoff_sym_fns);
|
|
}
|