static void macho_symtab_add_minsym (minimal_symbol_reader &reader, struct objfile *objfile, const asymbol *sym) { if (sym->name == NULL || *sym->name == '\0') { /* Skip names that don't exist (shouldn't happen), or names that are null strings (may happen). */ return; } if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK)) { CORE_ADDR symaddr; enum minimal_symbol_type ms_type; /* Bfd symbols are section relative. */ symaddr = sym->value + sym->section->vma; if (sym->section == bfd_abs_section_ptr) ms_type = mst_abs; else if (sym->section->flags & SEC_CODE) { if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) ms_type = mst_text; else ms_type = mst_file_text; } else if (sym->section->flags & SEC_ALLOC) { if (sym->flags & (BSF_GLOBAL | BSF_WEAK)) { if (sym->section->flags & SEC_LOAD) ms_type = mst_data; else ms_type = mst_bss; } else if (sym->flags & BSF_LOCAL) { /* Not a special stabs-in-elf symbol, do regular symbol processing. */ if (sym->section->flags & SEC_LOAD) ms_type = mst_file_data; else ms_type = mst_file_bss; } else ms_type = mst_unknown; } else return; /* Skip this symbol. */ reader.record_with_info (sym->name, symaddr, ms_type, gdb_bfd_section_index (objfile->obfd, sym->section)); } }
static void add_pe_exported_sym (minimal_symbol_reader &reader, const char *sym_name, unsigned long func_rva, int ordinal, const struct read_pe_section_data *section_data, const char *dll_name, struct objfile *objfile) { char *qualified_name, *bare_name; /* Add the stored offset to get the loaded address of the symbol. */ CORE_ADDR vma = func_rva + section_data->vma_offset; /* Generate a (hopefully unique) qualified name using the first part of the dll name, e.g. KERNEL32!AddAtomA. This matches the style used by windbg from the "Microsoft Debugging Tools for Windows". */ if (sym_name == NULL || *sym_name == '\0') bare_name = xstrprintf ("#%d", ordinal); else bare_name = xstrdup (sym_name); qualified_name = xstrprintf ("%s!%s", dll_name, bare_name); if ((section_data->ms_type == mst_unknown) && debug_coff_pe_read) fprintf_unfiltered (gdb_stdlog , _("Unknown section type for \"%s\"" " for entry \"%s\" in dll \"%s\"\n"), section_data->section_name, sym_name, dll_name); reader.record_with_info (qualified_name, vma, section_data->ms_type, section_data->index); /* Enter the plain name as well, which might not be unique. */ reader.record_with_info (bare_name, vma, section_data->ms_type, section_data->index); if (debug_coff_pe_read > 1) fprintf_unfiltered (gdb_stdlog, _("Adding exported symbol \"%s\"" " in dll \"%s\"\n"), sym_name, dll_name); xfree (qualified_name); xfree (bare_name); }
static int add_pe_forwarded_sym (minimal_symbol_reader &reader, const char *sym_name, const char *forward_dll_name, const char *forward_func_name, int ordinal, const char *dll_name, struct objfile *objfile) { CORE_ADDR vma, baseaddr; struct bound_minimal_symbol msymbol; enum minimal_symbol_type msymtype; char *qualified_name, *bare_name; int forward_dll_name_len = strlen (forward_dll_name); int forward_func_name_len = strlen (forward_func_name); int forward_len = forward_dll_name_len + forward_func_name_len + 2; char *forward_qualified_name = (char *) alloca (forward_len); short section; xsnprintf (forward_qualified_name, forward_len, "%s!%s", forward_dll_name, forward_func_name); msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name); if (!msymbol.minsym) { int i; for (i = 0; i < forward_dll_name_len; i++) forward_qualified_name[i] = tolower (forward_qualified_name[i]); msymbol = lookup_minimal_symbol_and_objfile (forward_qualified_name); } if (!msymbol.minsym) { if (debug_coff_pe_read) fprintf_unfiltered (gdb_stdlog, _("Unable to find function \"%s\" in" " dll \"%s\", forward of \"%s\" in dll \"%s\"\n"), forward_func_name, forward_dll_name, sym_name, dll_name); return 0; } if (debug_coff_pe_read > 1) fprintf_unfiltered (gdb_stdlog, _("Adding forwarded exported symbol" " \"%s\" in dll \"%s\", pointing to \"%s\"\n"), sym_name, dll_name, forward_qualified_name); vma = BMSYMBOL_VALUE_ADDRESS (msymbol); msymtype = MSYMBOL_TYPE (msymbol.minsym); section = MSYMBOL_SECTION (msymbol.minsym); /* Generate a (hopefully unique) qualified name using the first part of the dll name, e.g. KERNEL32!AddAtomA. This matches the style used by windbg from the "Microsoft Debugging Tools for Windows". */ if (sym_name == NULL || *sym_name == '\0') bare_name = xstrprintf ("#%d", ordinal); else bare_name = xstrdup (sym_name); qualified_name = xstrprintf ("%s!%s", dll_name, bare_name); /* Note that this code makes a minimal symbol whose value may point outside of any section in this objfile. These symbols can't really be relocated properly, but nevertheless we make a stab at it, choosing an approach consistent with the history of this code. */ baseaddr = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); reader.record_with_info (qualified_name, vma - baseaddr, msymtype, section); /* Enter the plain name as well, which might not be unique. */ reader.record_with_info (bare_name, vma - baseaddr, msymtype, section); xfree (qualified_name); xfree (bare_name); return 1; }
static void read_alphacoff_dynamic_symtab (minimal_symbol_reader &reader, 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; struct cleanup *cleanups; /* 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, (void *) & 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 (si.sym_sect); str_secsize = bfd_get_section_size (si.str_sect); dyninfo_secsize = bfd_get_section_size (si.dyninfo_sect); got_secsize = bfd_get_section_size (si.got_sect); sym_secptr = (char *) xmalloc (sym_secsize); cleanups = make_cleanup (xfree, sym_secptr); str_secptr = (char *) xmalloc (str_secsize); make_cleanup (xfree, str_secptr); dyninfo_secptr = (char *) xmalloc (dyninfo_secsize); make_cleanup (xfree, dyninfo_secptr); got_secptr = (char *) xmalloc (got_secsize); make_cleanup (xfree, got_secptr); if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr, (file_ptr) 0, sym_secsize)) { do_cleanups (cleanups); return; } if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr, (file_ptr) 0, str_secsize)) { do_cleanups (cleanups); return; } if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr, (file_ptr) 0, dyninfo_secsize)) { do_cleanups (cleanups); return; } if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr, (file_ptr) 0, got_secsize)) { do_cleanups (cleanups); return; } /* Find the number of local GOT entries and the index for 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) { if (dt_mips_local_gotno < 0) dt_mips_local_gotno = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val); } else if (dyn_tag == DT_MIPS_GOTSYM) { if (dt_mips_gotsym < 0) 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) { do_cleanups (cleanups); 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); if (sym_shndx >= (SHN_LORESERVE & 0xffff)) sym_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff); 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; } else if (sym_shndx == SHN_MIPS_DATA) { if (isglobal) ms_type = mst_data; else ms_type = mst_file_data; } else if (sym_shndx == SHN_MIPS_ACOMMON) { if (isglobal) ms_type = mst_bss; else ms_type = mst_file_bss; } else if (sym_shndx == SHN_ABS) { ms_type = mst_abs; } else { continue; } } reader.record (name, sym_value, ms_type); } do_cleanups (cleanups); }