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