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