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