1/* Read a symbol table in MIPS' format (Third-Eye). 2 3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1998, 1999, 2000, 2001, 2003, 2004, 2007 Free Software Foundation, Inc. 5 6 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work 7 by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 23 24/* Read symbols from an ECOFF file. Most of the work is done in 25 mdebugread.c. */ 26 27#include "defs.h" 28#include "gdb_string.h" 29#include "bfd.h" 30#include "symtab.h" 31#include "objfiles.h" 32#include "buildsym.h" 33#include "stabsread.h" 34 35#include "coff/sym.h" 36#include "coff/internal.h" 37#include "coff/ecoff.h" 38#include "libcoff.h" /* Private BFD COFF information. */ 39#include "libecoff.h" /* Private BFD ECOFF information. */ 40#include "elf/common.h" 41#include "elf/mips.h" 42 43static void 44read_alphacoff_dynamic_symtab (struct section_offsets *, 45 struct objfile *objfile); 46 47/* Initialize anything that needs initializing when a completely new 48 symbol file is specified (not just adding some symbols from another 49 file, e.g. a shared library). */ 50 51static void 52mipscoff_new_init (struct objfile *ignore) 53{ 54 stabsread_new_init (); 55 buildsym_new_init (); 56} 57 58/* Initialize to read a symbol file (nothing to do). */ 59 60static void 61mipscoff_symfile_init (struct objfile *objfile) 62{ 63} 64 65/* Read a symbol file from a file. */ 66 67static void 68mipscoff_symfile_read (struct objfile *objfile, int mainline) 69{ 70 bfd *abfd = objfile->obfd; 71 struct cleanup *back_to; 72 73 init_minimal_symbol_collection (); 74 back_to = make_cleanup_discard_minimal_symbols (); 75 76 /* Now that the executable file is positioned at symbol table, 77 process it and define symbols accordingly. */ 78 79 if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info) 80 (abfd, (asection *) NULL, &ecoff_data (abfd)->debug_info))) 81 error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ())); 82 83 mdebug_build_psymtabs (objfile, &ecoff_backend (abfd)->debug_swap, 84 &ecoff_data (abfd)->debug_info); 85 86 /* Add alpha coff dynamic symbols. */ 87 88 read_alphacoff_dynamic_symtab (objfile->section_offsets, objfile); 89 90 /* Install any minimal symbols that have been collected as the current 91 minimal symbols for this objfile. */ 92 93 install_minimal_symbols (objfile); 94 do_cleanups (back_to); 95} 96 97/* Perform any local cleanups required when we are done with a 98 particular objfile. */ 99 100static void 101mipscoff_symfile_finish (struct objfile *objfile) 102{ 103} 104 105/* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a 106 standard COFF section. The ELF format for the symbols differs from 107 the format defined in elf/external.h. It seems that a normal ELF 108 32-bit format is used, and the representation only changes because 109 longs are 64-bit on the alpha. In addition, the handling of 110 text/data section indices for symbols is different from the ELF 111 ABI. As the BFD linker currently does not support dynamic linking 112 on the alpha, there seems to be no reason to pollute BFD with 113 another mixture of object file formats for now. */ 114 115/* Format of an alpha external ELF symbol. */ 116 117typedef struct 118{ 119 unsigned char st_name[4]; /* Symbol name, index in string table. */ 120 unsigned char st_pad[4]; /* Pad to long word boundary. */ 121 unsigned char st_value[8]; /* Value of the symbol. */ 122 unsigned char st_size[4]; /* Associated symbol size. */ 123 unsigned char st_info[1]; /* Type and binding attributes. */ 124 unsigned char st_other[1]; /* No defined meaning, 0. */ 125 unsigned char st_shndx[2]; /* Associated section index. */ 126} Elfalpha_External_Sym; 127 128/* Format of an alpha external ELF dynamic info structure. */ 129 130typedef struct 131{ 132 unsigned char d_tag[4]; /* Tag. */ 133 unsigned char d_pad[4]; /* Pad to long word boundary. */ 134 union 135 { 136 unsigned char d_ptr[8]; /* Pointer value. */ 137 unsigned char d_val[4]; /* Integer value. */ 138 } 139 d_un; 140} Elfalpha_External_Dyn; 141 142/* Struct to obtain the section pointers for alpha dynamic symbol info. */ 143 144struct alphacoff_dynsecinfo 145{ 146 asection *sym_sect; /* Section pointer for .dynsym section. */ 147 asection *str_sect; /* Section pointer for .dynstr section. */ 148 asection *dyninfo_sect; /* Section pointer for .dynamic section. */ 149 asection *got_sect; /* Section pointer for .got section. */ 150}; 151 152/* We are called once per section from read_alphacoff_dynamic_symtab. 153 We need to examine each section we are passed, check to see if it 154 is something we are interested in processing, and if so, stash away 155 some access information for the section. */ 156 157static void 158alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip) 159{ 160 struct alphacoff_dynsecinfo *si; 161 162 si = (struct alphacoff_dynsecinfo *) sip; 163 164 if (strcmp (sectp->name, ".dynsym") == 0) 165 si->sym_sect = sectp; 166 else if (strcmp (sectp->name, ".dynstr") == 0) 167 si->str_sect = sectp; 168 else if (strcmp (sectp->name, ".dynamic") == 0) 169 si->dyninfo_sect = sectp; 170 else if (strcmp (sectp->name, ".got") == 0) 171 si->got_sect = sectp; 172} 173 174/* Scan an alpha dynamic symbol table for symbols of interest and add 175 them to the minimal symbol table. */ 176 177static void 178read_alphacoff_dynamic_symtab (struct section_offsets *section_offsets, 179 struct objfile *objfile) 180{ 181 bfd *abfd = objfile->obfd; 182 struct alphacoff_dynsecinfo si; 183 char *sym_secptr; 184 char *str_secptr; 185 char *dyninfo_secptr; 186 char *got_secptr; 187 bfd_size_type sym_secsize; 188 bfd_size_type str_secsize; 189 bfd_size_type dyninfo_secsize; 190 bfd_size_type got_secsize; 191 int sym_count; 192 int i; 193 int stripped; 194 Elfalpha_External_Sym *x_symp; 195 char *dyninfo_p; 196 char *dyninfo_end; 197 int got_entry_size = 8; 198 int dt_mips_local_gotno = -1; 199 int dt_mips_gotsym = -1; 200 struct cleanup *cleanups; 201 202 /* We currently only know how to handle alpha dynamic symbols. */ 203 if (bfd_get_arch (abfd) != bfd_arch_alpha) 204 return; 205 206 /* Locate the dynamic symbols sections and read them in. */ 207 memset ((char *) &si, 0, sizeof (si)); 208 bfd_map_over_sections (abfd, alphacoff_locate_sections, (void *) & si); 209 if (si.sym_sect == NULL || si.str_sect == NULL 210 || si.dyninfo_sect == NULL || si.got_sect == NULL) 211 return; 212 213 sym_secsize = bfd_get_section_size (si.sym_sect); 214 str_secsize = bfd_get_section_size (si.str_sect); 215 dyninfo_secsize = bfd_get_section_size (si.dyninfo_sect); 216 got_secsize = bfd_get_section_size (si.got_sect); 217 sym_secptr = xmalloc (sym_secsize); 218 cleanups = make_cleanup (free, sym_secptr); 219 str_secptr = xmalloc (str_secsize); 220 make_cleanup (free, str_secptr); 221 dyninfo_secptr = xmalloc (dyninfo_secsize); 222 make_cleanup (free, dyninfo_secptr); 223 got_secptr = xmalloc (got_secsize); 224 make_cleanup (free, got_secptr); 225 226 if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr, 227 (file_ptr) 0, sym_secsize)) 228 return; 229 if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr, 230 (file_ptr) 0, str_secsize)) 231 return; 232 if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr, 233 (file_ptr) 0, dyninfo_secsize)) 234 return; 235 if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr, 236 (file_ptr) 0, got_secsize)) 237 return; 238 239 /* Find the number of local GOT entries and the index for the the 240 first dynamic symbol in the GOT. */ 241 for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize; 242 dyninfo_p < dyninfo_end; 243 dyninfo_p += sizeof (Elfalpha_External_Dyn)) 244 { 245 Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p; 246 long dyn_tag; 247 248 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag); 249 if (dyn_tag == DT_NULL) 250 break; 251 else if (dyn_tag == DT_MIPS_LOCAL_GOTNO) 252 { 253 if (dt_mips_local_gotno < 0) 254 dt_mips_local_gotno 255 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val); 256 } 257 else if (dyn_tag == DT_MIPS_GOTSYM) 258 { 259 if (dt_mips_gotsym < 0) 260 dt_mips_gotsym 261 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val); 262 } 263 } 264 if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0) 265 return; 266 267 /* Scan all dynamic symbols and enter them into the minimal symbol 268 table if appropriate. */ 269 sym_count = sym_secsize / sizeof (Elfalpha_External_Sym); 270 stripped = (bfd_get_symcount (abfd) == 0); 271 272 /* Skip first symbol, which is a null dummy. */ 273 for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1; 274 i < sym_count; 275 i++, x_symp++) 276 { 277 unsigned long strx; 278 char *name; 279 bfd_vma sym_value; 280 unsigned char sym_info; 281 unsigned int sym_shndx; 282 int isglobal; 283 enum minimal_symbol_type ms_type; 284 285 strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name); 286 if (strx >= str_secsize) 287 continue; 288 name = str_secptr + strx; 289 if (*name == '\0' || *name == '.') 290 continue; 291 292 sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value); 293 sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info); 294 sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx); 295 isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL); 296 297 if (sym_shndx == SHN_UNDEF) 298 { 299 /* Handle undefined functions which are defined in a shared 300 library. */ 301 if (ELF_ST_TYPE (sym_info) != STT_FUNC 302 || ELF_ST_BIND (sym_info) != STB_GLOBAL) 303 continue; 304 305 ms_type = mst_solib_trampoline; 306 307 /* If sym_value is nonzero, it points to the shared library 308 trampoline entry, which is what we are looking for. 309 310 If sym_value is zero, then we have to get the GOT entry 311 for the symbol. 312 313 If the GOT entry is nonzero, it represents the quickstart 314 address of the function and we use that as the symbol 315 value. 316 317 If the GOT entry is zero, the function address has to be 318 resolved by the runtime loader before the executable is 319 started. We are unable to find any meaningful address 320 for these functions in the executable file, so we skip 321 them. */ 322 if (sym_value == 0) 323 { 324 int got_entry_offset = 325 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size; 326 327 if (got_entry_offset < 0 || got_entry_offset >= got_secsize) 328 continue; 329 sym_value = 330 bfd_h_get_64 (abfd, 331 (bfd_byte *) (got_secptr + got_entry_offset)); 332 if (sym_value == 0) 333 continue; 334 } 335 } 336 else 337 { 338 /* Symbols defined in the executable itself. We only care 339 about them if this is a stripped executable, otherwise 340 they have been retrieved from the normal symbol table 341 already. */ 342 if (!stripped) 343 continue; 344 345 if (sym_shndx == SHN_MIPS_TEXT) 346 { 347 if (isglobal) 348 ms_type = mst_text; 349 else 350 ms_type = mst_file_text; 351 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 352 } 353 else if (sym_shndx == SHN_MIPS_DATA) 354 { 355 if (isglobal) 356 ms_type = mst_data; 357 else 358 ms_type = mst_file_data; 359 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); 360 } 361 else if (sym_shndx == SHN_MIPS_ACOMMON) 362 { 363 if (isglobal) 364 ms_type = mst_bss; 365 else 366 ms_type = mst_file_bss; 367 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile)); 368 } 369 else if (sym_shndx == SHN_ABS) 370 { 371 ms_type = mst_abs; 372 } 373 else 374 { 375 continue; 376 } 377 } 378 379 prim_record_minimal_symbol (name, sym_value, ms_type, objfile); 380 } 381 382 do_cleanups (cleanups); 383} 384 385/* Initialization. */ 386 387static struct sym_fns ecoff_sym_fns = 388{ 389 bfd_target_ecoff_flavour, 390 mipscoff_new_init, /* sym_new_init: init anything gbl to entire symtab */ 391 mipscoff_symfile_init, /* sym_init: read initial info, setup for sym_read() */ 392 mipscoff_symfile_read, /* sym_read: read a symbol file into symtab */ 393 mipscoff_symfile_finish, /* sym_finish: finished with file, cleanup */ 394 default_symfile_offsets, /* sym_offsets: dummy FIXME til implem sym reloc */ 395 default_symfile_segments, /* sym_segments: Get segment information from 396 a file. */ 397 NULL /* next: pointer to next struct sym_fns */ 398}; 399 400/* Provide a prototype to silence -Wmissing-prototypes. */ 401void _initialize_mipsread (void); 402 403void 404_initialize_mipsread (void) 405{ 406 add_symtab_fns (&ecoff_sym_fns); 407} 408