From 086df311266af5a41ac06691cc1dcdfeee4fcb47 Mon Sep 17 00:00:00 2001 From: Daniel Jacobowitz Date: Fri, 31 Jan 2003 19:22:18 +0000 Subject: [PATCH] * dbxread.c (stabs_data): New static variable. (fill_symbuf): Support an in-memory buffer for stabs data. (stabs_seek): New function. (dbx_psymtab_to_symtab): Relocate the stabs data if necessary. (read_ofile_symtab): Use stabs_seek. (elfstab_build_psymtabs): Take an asection* instead of an offset and size. Relocate the stabs data if necessary. Save the section* for dbx_psymtab_to_symtab. * dwarf2read.c: Add section variables for each debug section. (dwarf2_locate_sections): Fill them in. (dwarf2_read_section): Take an asection* argument. Relocate the section contents if necessary. (dwarf2_build_psymtabs, dwarf2_build_psymtabs_easy): Update callers. * dwarf2cfi.c (parse_frame_info): Take a section argument and pass it to dwarf2_read_section. (dwarf2_build_frame_info): Update callers. * elfread.c (elf_symfile_read): Update call to elfstab_build_psymtabs. * gdb-stabs.h (struct dbx_symfile_info): Add stab_section. (DBX_STAB_SECTION): New macro. * stabsread.h (elfstab_build_psymtabs): Update prototype. * symfile.c (symfile_dummy_outputs): New function. (symfile_relocate_debug_section): New function. * symfile.h (symfile_relocate_debug_section): Add prototype. --- gdb/ChangeLog | 27 ++++++++++++++++++ gdb/dbxread.c | 73 +++++++++++++++++++++++++++++++++++++++++------- gdb/dwarf2cfi.c | 15 +++++++--- gdb/dwarf2read.c | 60 +++++++++++++++++++++++++++++++-------- gdb/elfread.c | 3 +- gdb/gdb-stabs.h | 4 +++ gdb/stabsread.h | 2 +- gdb/symfile.c | 40 ++++++++++++++++++++++++++ gdb/symfile.h | 5 +++- 9 files changed, 199 insertions(+), 30 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 4c225a9cffe..696fbcdf693 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,30 @@ +2003-01-31 Daniel Jacobowitz + + * dbxread.c (stabs_data): New static variable. + (fill_symbuf): Support an in-memory buffer for stabs data. + (stabs_seek): New function. + (dbx_psymtab_to_symtab): Relocate the stabs data if necessary. + (read_ofile_symtab): Use stabs_seek. + (elfstab_build_psymtabs): Take an asection* instead of + an offset and size. Relocate the stabs data if necessary. + Save the section* for dbx_psymtab_to_symtab. + * dwarf2read.c: Add section variables for each debug section. + (dwarf2_locate_sections): Fill them in. + (dwarf2_read_section): Take an asection* argument. + Relocate the section contents if necessary. + (dwarf2_build_psymtabs, dwarf2_build_psymtabs_easy): Update callers. + * dwarf2cfi.c (parse_frame_info): Take a section argument and pass + it to dwarf2_read_section. + (dwarf2_build_frame_info): Update callers. + * elfread.c (elf_symfile_read): Update call to + elfstab_build_psymtabs. + * gdb-stabs.h (struct dbx_symfile_info): Add stab_section. + (DBX_STAB_SECTION): New macro. + * stabsread.h (elfstab_build_psymtabs): Update prototype. + * symfile.c (symfile_dummy_outputs): New function. + (symfile_relocate_debug_section): New function. + * symfile.h (symfile_relocate_debug_section): Add prototype. + 2003-01-31 Richard Henderson * alpha-nat.c (REGISTER_PTRACE_ADDR): Merge into ... diff --git a/gdb/dbxread.c b/gdb/dbxread.c index c533eb4c290..2a1d4e20c69 100644 --- a/gdb/dbxread.c +++ b/gdb/dbxread.c @@ -893,6 +893,10 @@ static struct stab_section_list *symbuf_sections; static unsigned int symbuf_left; static unsigned int symbuf_read; +/* This variable stores a global stabs buffer, if we read stabs into + memory in one chunk in order to process relocations. */ +static bfd_byte *stabs_data; + /* Refill the symbol table input buffer and set the variables that control fetching entries from it. Reports an error if no data available. @@ -905,8 +909,18 @@ fill_symbuf (bfd *sym_bfd) unsigned int count; int nbytes; - if (symbuf_sections == NULL) - count = sizeof (symbuf); + if (stabs_data) + { + nbytes = sizeof (symbuf); + if (nbytes > symbuf_left) + nbytes = symbuf_left; + memcpy (symbuf, stabs_data + symbuf_read, nbytes); + } + else if (symbuf_sections == NULL) + { + count = sizeof (symbuf); + nbytes = bfd_bread (symbuf, count, sym_bfd); + } else { if (symbuf_left <= 0) @@ -922,9 +936,9 @@ fill_symbuf (bfd *sym_bfd) count = symbuf_left; if (count > sizeof (symbuf)) count = sizeof (symbuf); + nbytes = bfd_bread (symbuf, count, sym_bfd); } - nbytes = bfd_bread (symbuf, count, sym_bfd); if (nbytes < 0) perror_with_name (bfd_get_filename (sym_bfd)); else if (nbytes == 0) @@ -935,6 +949,18 @@ fill_symbuf (bfd *sym_bfd) symbuf_read += nbytes; } +static void +stabs_seek (int sym_offset) +{ + if (stabs_data) + { + symbuf_read += sym_offset; + symbuf_left -= sym_offset; + } + else + bfd_seek (symfile_bfd, sym_offset, SEEK_CUR); +} + #define INTERNALIZE_SYMBOL(intern, extern, abfd) \ { \ (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \ @@ -2473,6 +2499,7 @@ static void dbx_psymtab_to_symtab (struct partial_symtab *pst) { bfd *sym_bfd; + struct cleanup *back_to = NULL; if (!pst) return; @@ -2498,8 +2525,21 @@ dbx_psymtab_to_symtab (struct partial_symtab *pst) next_symbol_text_func = dbx_next_symbol_text; + if (DBX_STAB_SECTION (pst->objfile)) + { + stabs_data + = symfile_relocate_debug_section (pst->objfile->obfd, + DBX_STAB_SECTION (pst->objfile), + NULL); + if (stabs_data) + back_to = make_cleanup (free_current_contents, (void *) &stabs_data); + } + dbx_psymtab_to_symtab_1 (pst); + if (back_to) + do_cleanups (back_to); + /* Match with global symbols. This only needs to be done once, after all of the symtabs and dependencies have been read in. */ scan_file_globals (pst->objfile); @@ -2548,6 +2588,8 @@ read_ofile_symtab (struct partial_symtab *pst) abfd = objfile->obfd; symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */ symbuf_end = symbuf_idx = 0; + symbuf_read = 0; + symbuf_left = sym_offset + sym_size; /* It is necessary to actually read one symbol *before* the start of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL @@ -2557,7 +2599,7 @@ read_ofile_symtab (struct partial_symtab *pst) would slow down initial readin, so we look for it here instead. */ if (!processing_acc_compilation && sym_offset >= (int) symbol_size) { - bfd_seek (symfile_bfd, sym_offset - symbol_size, SEEK_CUR); + stabs_seek (sym_offset - symbol_size); fill_symbuf (abfd); bufp = &symbuf[symbuf_idx++]; INTERNALIZE_SYMBOL (nlist, bufp, abfd); @@ -2600,7 +2642,7 @@ read_ofile_symtab (struct partial_symtab *pst) /* The N_SO starting this symtab is the first symbol, so we better not check the symbol before it. I'm not this can happen, but it doesn't hurt to check for it. */ - bfd_seek (symfile_bfd, sym_offset, SEEK_CUR); + stabs_seek (sym_offset); processing_gcc_compilation = 0; } @@ -3460,8 +3502,7 @@ coffstab_build_psymtabs (struct objfile *objfile, int mainline, the base address of the text segment). MAINLINE is true if we are reading the main symbol table (as opposed to a shared lib or dynamically loaded file). - STABOFFSET and STABSIZE define the location in OBJFILE where the .stab - section exists. + STABSECT is the BFD section information for the .stab section. STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the .stabstr section exists. @@ -3470,13 +3511,14 @@ coffstab_build_psymtabs (struct objfile *objfile, int mainline, void elfstab_build_psymtabs (struct objfile *objfile, int mainline, - file_ptr staboffset, unsigned int stabsize, + asection *stabsect, file_ptr stabstroffset, unsigned int stabstrsize) { int val; bfd *sym_bfd = objfile->obfd; char *name = bfd_get_filename (sym_bfd); struct dbx_symfile_info *info; + struct cleanup *back_to = NULL; /* There is already a dbx_symfile_info allocated by our caller. It might even contain some info from the ELF symtab to help us. */ @@ -3488,9 +3530,11 @@ elfstab_build_psymtabs (struct objfile *objfile, int mainline, #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */ DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE; - DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile); + DBX_SYMCOUNT (objfile) + = bfd_section_size (objfile->obfd, stabsect) / DBX_SYMBOL_SIZE (objfile); DBX_STRINGTAB_SIZE (objfile) = stabstrsize; - DBX_SYMTAB_OFFSET (objfile) = staboffset; + DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; + DBX_STAB_SECTION (objfile) = stabsect; if (stabstrsize > bfd_get_size (sym_bfd)) error ("ridiculous string table size: %d bytes", stabstrsize); @@ -3515,10 +3559,19 @@ elfstab_build_psymtabs (struct objfile *objfile, int mainline, processing_acc_compilation = 1; + symbuf_read = 0; + symbuf_left = bfd_section_size (objfile->obfd, stabsect); + stabs_data = symfile_relocate_debug_section (objfile->obfd, stabsect, NULL); + if (stabs_data) + back_to = make_cleanup (free_current_contents, (void *) &stabs_data); + /* In an elf file, we've already installed the minimal symbols that came from the elf (non-stab) symbol table, so always act like an incremental load here. */ dbx_symfile_read (objfile, 0); + + if (back_to) + do_cleanups (back_to); } /* Scan and build partial symbols for a file with special sections for stabs diff --git a/gdb/dwarf2cfi.c b/gdb/dwarf2cfi.c index 79ba41872f5..c92885574c5 100644 --- a/gdb/dwarf2cfi.c +++ b/gdb/dwarf2cfi.c @@ -170,10 +170,13 @@ extern file_ptr dwarf_frame_offset; extern unsigned int dwarf_frame_size; extern file_ptr dwarf_eh_frame_offset; extern unsigned int dwarf_eh_frame_size; +extern asection *dwarf_frame_section; +extern asection *dwarf_eh_frame_section; + extern char *dwarf2_read_section (struct objfile *objfile, file_ptr offset, - unsigned int size); + unsigned int size, asection* sectp); static struct fde_unit *fde_unit_alloc (void); static struct cie_unit *cie_unit_alloc (void); @@ -1368,7 +1371,8 @@ compare_fde_unit (const void *a, const void *b) -- mludvig */ static void parse_frame_info (struct objfile *objfile, file_ptr frame_offset, - unsigned int frame_size, int eh_frame) + unsigned int frame_size, asection *frame_section, + int eh_frame) { bfd *abfd = objfile->obfd; asection *curr_section_ptr; @@ -1383,7 +1387,8 @@ parse_frame_info (struct objfile *objfile, file_ptr frame_offset, unwind_tmp_obstack_init (); - frame_buffer = dwarf2_read_section (objfile, frame_offset, frame_size); + frame_buffer = dwarf2_read_section (objfile, frame_offset, frame_size, + frame_section); start = frame_buffer; end = frame_buffer + frame_size; @@ -1636,12 +1641,14 @@ dwarf2_build_frame_info (struct objfile *objfile) if (dwarf_frame_offset) { parse_frame_info (objfile, dwarf_frame_offset, - dwarf_frame_size, 0 /* = debug_frame */ ); + dwarf_frame_size, dwarf_frame_section, + 0 /* = debug_frame */ ); after_debug_frame = 1; } if (dwarf_eh_frame_offset) parse_frame_info (objfile, dwarf_eh_frame_offset, dwarf_eh_frame_size, + dwarf_eh_frame_section, 1 /* = eh_frame */ + after_debug_frame); } diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index fdc05e14477..a876043589b 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -1,5 +1,5 @@ /* DWARF 2 debugging format support for GDB. - Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 + Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. Adapted by Gary Funck (gary@intrepid.com), Intrepid Technology, @@ -149,6 +149,18 @@ static unsigned int dwarf_ranges_size; unsigned int dwarf_frame_size; unsigned int dwarf_eh_frame_size; +static asection *dwarf_info_section; +static asection *dwarf_abbrev_section; +static asection *dwarf_line_section; +static asection *dwarf_pubnames_section; +static asection *dwarf_aranges_section; +static asection *dwarf_loc_section; +static asection *dwarf_macinfo_section; +static asection *dwarf_str_section; +static asection *dwarf_ranges_section; +asection *dwarf_frame_section; +asection *dwarf_eh_frame_section; + /* names of the debugging sections */ #define INFO_SECTION ".debug_info" @@ -658,7 +670,8 @@ static void dwarf2_psymtab_to_symtab (struct partial_symtab *); static void psymtab_to_symtab_1 (struct partial_symtab *); -char *dwarf2_read_section (struct objfile *, file_ptr, unsigned int); +char *dwarf2_read_section (struct objfile *, file_ptr, unsigned int, + asection *); static void dwarf2_read_abbrevs (bfd *abfd, struct comp_unit_head *cu_header); @@ -929,51 +942,61 @@ dwarf2_locate_sections (bfd *ignore_abfd, asection *sectp, void *ignore_ptr) { dwarf_info_offset = sectp->filepos; dwarf_info_size = bfd_get_section_size_before_reloc (sectp); + dwarf_info_section = sectp; } else if (STREQ (sectp->name, ABBREV_SECTION)) { dwarf_abbrev_offset = sectp->filepos; dwarf_abbrev_size = bfd_get_section_size_before_reloc (sectp); + dwarf_abbrev_section = sectp; } else if (STREQ (sectp->name, LINE_SECTION)) { dwarf_line_offset = sectp->filepos; dwarf_line_size = bfd_get_section_size_before_reloc (sectp); + dwarf_line_section = sectp; } else if (STREQ (sectp->name, PUBNAMES_SECTION)) { dwarf_pubnames_offset = sectp->filepos; dwarf_pubnames_size = bfd_get_section_size_before_reloc (sectp); + dwarf_pubnames_section = sectp; } else if (STREQ (sectp->name, ARANGES_SECTION)) { dwarf_aranges_offset = sectp->filepos; dwarf_aranges_size = bfd_get_section_size_before_reloc (sectp); + dwarf_aranges_section = sectp; } else if (STREQ (sectp->name, LOC_SECTION)) { dwarf_loc_offset = sectp->filepos; dwarf_loc_size = bfd_get_section_size_before_reloc (sectp); + dwarf_loc_section = sectp; } else if (STREQ (sectp->name, MACINFO_SECTION)) { dwarf_macinfo_offset = sectp->filepos; dwarf_macinfo_size = bfd_get_section_size_before_reloc (sectp); + dwarf_loc_section = sectp; } else if (STREQ (sectp->name, STR_SECTION)) { dwarf_str_offset = sectp->filepos; dwarf_str_size = bfd_get_section_size_before_reloc (sectp); + dwarf_str_section = sectp; } else if (STREQ (sectp->name, FRAME_SECTION)) { dwarf_frame_offset = sectp->filepos; dwarf_frame_size = bfd_get_section_size_before_reloc (sectp); + dwarf_frame_section = sectp; } else if (STREQ (sectp->name, EH_FRAME_SECTION)) { dwarf_eh_frame_offset = sectp->filepos; dwarf_eh_frame_size = bfd_get_section_size_before_reloc (sectp); + dwarf_eh_frame_section = sectp; } else if (STREQ (sectp->name, RANGES_SECTION)) { @@ -992,36 +1015,42 @@ dwarf2_build_psymtabs (struct objfile *objfile, int mainline) dwarf_info_buffer = dwarf2_read_section (objfile, dwarf_info_offset, - dwarf_info_size); + dwarf_info_size, + dwarf_info_section); dwarf_abbrev_buffer = dwarf2_read_section (objfile, dwarf_abbrev_offset, - dwarf_abbrev_size); + dwarf_abbrev_size, + dwarf_abbrev_section); if (dwarf_line_offset) dwarf_line_buffer = dwarf2_read_section (objfile, dwarf_line_offset, - dwarf_line_size); + dwarf_line_size, + dwarf_line_section); else dwarf_line_buffer = NULL; if (dwarf_str_offset) dwarf_str_buffer = dwarf2_read_section (objfile, dwarf_str_offset, - dwarf_str_size); + dwarf_str_size, + dwarf_str_section); else dwarf_str_buffer = NULL; if (dwarf_macinfo_offset) dwarf_macinfo_buffer = dwarf2_read_section (objfile, dwarf_macinfo_offset, - dwarf_macinfo_size); + dwarf_macinfo_size, + dwarf_macinfo_section); else dwarf_macinfo_buffer = NULL; if (dwarf_ranges_offset) dwarf_ranges_buffer = dwarf2_read_section (objfile, dwarf_ranges_offset, - dwarf_ranges_size); + dwarf_ranges_size, + dwarf_ranges_section); else dwarf_ranges_buffer = NULL; @@ -1063,7 +1092,8 @@ dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) pubnames_buffer = dwarf2_read_section (objfile, dwarf_pubnames_offset, - dwarf_pubnames_size); + dwarf_pubnames_size, + dwarf_pubnames_section); pubnames_ptr = pubnames_buffer; while ((pubnames_ptr - pubnames_buffer) < dwarf_pubnames_size) { @@ -1083,7 +1113,8 @@ dwarf2_build_psymtabs_easy (struct objfile *objfile, int mainline) aranges_buffer = dwarf2_read_section (objfile, dwarf_aranges_offset, - dwarf_aranges_size); + dwarf_aranges_size, + dwarf_aranges_section); } #endif @@ -3584,15 +3615,20 @@ make_cleanup_free_die_list (struct die_info *dies) char * dwarf2_read_section (struct objfile *objfile, file_ptr offset, - unsigned int size) + unsigned int size, asection *sectp) { bfd *abfd = objfile->obfd; - char *buf; + char *buf, *retbuf; if (size == 0) return NULL; buf = (char *) obstack_alloc (&objfile->psymbol_obstack, size); + retbuf + = (char *) symfile_relocate_debug_section (abfd, sectp, (bfd_byte *) buf); + if (retbuf != NULL) + return retbuf; + if ((bfd_seek (abfd, offset, SEEK_SET) != 0) || (bfd_bread (buf, size, abfd) != size)) { diff --git a/gdb/elfread.c b/gdb/elfread.c index 5eaeed02426..b96d6e7ff28 100644 --- a/gdb/elfread.c +++ b/gdb/elfread.c @@ -591,8 +591,7 @@ elf_symfile_read (struct objfile *objfile, int mainline) if (str_sect) elfstab_build_psymtabs (objfile, mainline, - ei.stabsect->filepos, - bfd_section_size (abfd, ei.stabsect), + ei.stabsect, str_sect->filepos, bfd_section_size (abfd, str_sect)); } diff --git a/gdb/gdb-stabs.h b/gdb/gdb-stabs.h index d2da2d11d99..abe2d3365b6 100644 --- a/gdb/gdb-stabs.h +++ b/gdb/gdb-stabs.h @@ -70,6 +70,9 @@ struct dbx_symfile_info asection *text_section; asection *data_section; asection *bss_section; + + /* Pointer to the separate ".stab" section, if there is one. */ + asection *stab_section; }; #define DBX_SYMFILE_INFO(o) ((o)->sym_stab_info) @@ -83,5 +86,6 @@ struct dbx_symfile_info #define DBX_TEXT_SECTION(o) (DBX_SYMFILE_INFO(o)->text_section) #define DBX_DATA_SECTION(o) (DBX_SYMFILE_INFO(o)->data_section) #define DBX_BSS_SECTION(o) (DBX_SYMFILE_INFO(o)->bss_section) +#define DBX_STAB_SECTION(o) (DBX_SYMFILE_INFO(o)->stab_section) #endif /* GDBSTABS_H */ diff --git a/gdb/stabsread.h b/gdb/stabsread.h index 9f15642f241..62fd77601ad 100644 --- a/gdb/stabsread.h +++ b/gdb/stabsread.h @@ -181,7 +181,7 @@ extern void process_one_symbol (int, int, CORE_ADDR, char *, extern void elfstab_build_psymtabs (struct objfile *objfile, int mainline, - file_ptr staboff, unsigned int stabsize, + asection *stabsect, file_ptr stabstroffset, unsigned int stabstrsize); diff --git a/gdb/symfile.c b/gdb/symfile.c index 81e1f7446fe..95da6f12416 100644 --- a/gdb/symfile.c +++ b/gdb/symfile.c @@ -23,6 +23,7 @@ Boston, MA 02111-1307, USA. */ #include "defs.h" +#include "bfdlink.h" #include "symtab.h" #include "gdbtypes.h" #include "gdbcore.h" @@ -3562,6 +3563,45 @@ simple_overlay_update (struct obj_section *osect) } } +/* Set the output sections and output offsets for section SECTP in + ABFD. The relocation code in BFD will read these offsets, so we + need to be sure they're initialized. We map each section to itself, + with no offset; this means that SECTP->vma will be honored. */ + +static void +symfile_dummy_outputs (bfd *abfd, asection *sectp, void *dummy) +{ + sectp->output_section = sectp; + sectp->output_offset = 0; +} + +/* Relocate the contents of a debug section SECTP in ABFD. The + contents are stored in BUF if it is non-NULL, or returned in a + malloc'd buffer otherwise. + + For some platforms and debug info formats, shared libraries contain + relocations against the debug sections (particularly for DWARF-2; + one affected platform is PowerPC GNU/Linux, although it depends on + the version of the linker in use). Also, ELF object files naturally + have unresolved relocations for their debug sections. We need to apply + the relocations in order to get the locations of symbols correct. */ + +bfd_byte * +symfile_relocate_debug_section (bfd *abfd, asection *sectp, bfd_byte *buf) +{ + /* We're only interested in debugging sections with relocation + information. */ + if ((sectp->flags & SEC_RELOC) == 0) + return NULL; + if ((sectp->flags & SEC_DEBUGGING) == 0) + return NULL; + + /* We will handle section offsets properly elsewhere, so relocate as if + all sections begin at 0. */ + bfd_map_over_sections (abfd, symfile_dummy_outputs, NULL); + + return bfd_simple_get_relocated_section_contents (abfd, sectp, buf); +} void _initialize_symfile (void) diff --git a/gdb/symfile.h b/gdb/symfile.h index 060eb4cdee9..267146375c6 100644 --- a/gdb/symfile.h +++ b/gdb/symfile.h @@ -1,6 +1,6 @@ /* Definitions for reading symbol files into GDB. Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, - 2000, 2001 + 2000, 2001, 2002, 2003 Free Software Foundation, Inc. This file is part of GDB. @@ -300,6 +300,9 @@ extern void symbol_file_add_main (char *args, int from_tty); /* Clear GDB symbol tables. */ extern void symbol_file_clear (int from_tty); +extern bfd_byte *symfile_relocate_debug_section (bfd *abfd, asection *sectp, + bfd_byte *buf); + /* From dwarfread.c */ extern void -- 2.30.2