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