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.
8 This file is part of GDB.
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.
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.
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. */
25 /* Read symbols from an ECOFF file. Most of the work is done in
29 #include "gdb_string.h"
34 #include "stabsread.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"
44 extern void _initialize_mipsread (void);
46 static void mipscoff_new_init (struct objfile *);
48 static void mipscoff_symfile_init (struct objfile *);
50 static void mipscoff_symfile_read (struct objfile *, int);
52 static void mipscoff_symfile_finish (struct objfile *);
55 read_alphacoff_dynamic_symtab (struct section_offsets *,
56 struct objfile *objfile);
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). */
63 mipscoff_new_init (struct objfile *ignore)
65 stabsread_new_init ();
69 /* Initialize to read a symbol file (nothing to do). */
72 mipscoff_symfile_init (struct objfile *objfile)
76 /* Read a symbol file from a file. */
79 mipscoff_symfile_read (struct objfile *objfile, int mainline)
81 bfd *abfd = objfile->obfd;
82 struct cleanup *back_to;
84 init_minimal_symbol_collection ();
85 back_to = make_cleanup_discard_minimal_symbols ();
87 /* Now that the executable file is positioned at symbol table,
88 process it and define symbols accordingly. */
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 ()));
94 mdebug_build_psymtabs (objfile, &ecoff_backend (abfd)->debug_swap,
95 &ecoff_data (abfd)->debug_info);
97 /* Add alpha coff dynamic symbols. */
99 read_alphacoff_dynamic_symtab (objfile->section_offsets, objfile);
101 /* Install any minimal symbols that have been collected as the current
102 minimal symbols for this objfile. */
104 install_minimal_symbols (objfile);
105 do_cleanups (back_to);
108 /* Perform any local cleanups required when we are done with a
109 particular objfile. */
112 mipscoff_symfile_finish (struct objfile *objfile)
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. */
126 /* Format of an alpha external ELF symbol. */
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 */
138 Elfalpha_External_Sym;
140 /* Format of an alpha external ELF dynamic info structure. */
144 unsigned char d_tag[4]; /* Tag */
145 unsigned char d_pad[4]; /* Pad to long word boundary */
148 unsigned char d_ptr[8]; /* Pointer value */
149 unsigned char d_val[4]; /* Integer value */
153 Elfalpha_External_Dyn;
155 /* Struct to obtain the section pointers for alpha dynamic symbol info. */
157 struct alphacoff_dynsecinfo
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 */
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. */
171 alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip)
173 struct alphacoff_dynsecinfo *si;
175 si = (struct alphacoff_dynsecinfo *) sip;
177 if (DEPRECATED_STREQ (sectp->name, ".dynsym"))
179 si->sym_sect = sectp;
181 else if (DEPRECATED_STREQ (sectp->name, ".dynstr"))
183 si->str_sect = sectp;
185 else if (DEPRECATED_STREQ (sectp->name, ".dynamic"))
187 si->dyninfo_sect = sectp;
189 else if (DEPRECATED_STREQ (sectp->name, ".got"))
191 si->got_sect = sectp;
195 /* Scan an alpha dynamic symbol table for symbols of interest and
196 add them to the minimal symbol table. */
199 read_alphacoff_dynamic_symtab (struct section_offsets *section_offsets,
200 struct objfile *objfile)
202 bfd *abfd = objfile->obfd;
203 struct alphacoff_dynsecinfo si;
206 char *dyninfo_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;
215 Elfalpha_External_Sym *x_symp;
218 int got_entry_size = 8;
219 int dt_mips_local_gotno = -1;
220 int dt_mips_gotsym = -1;
221 struct cleanup *cleanups;
224 /* We currently only know how to handle alpha dynamic symbols. */
225 if (bfd_get_arch (abfd) != bfd_arch_alpha)
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)
237 sym_secsize = bfd_get_section_size_before_reloc (si.sym_sect);
238 str_secsize = bfd_get_section_size_before_reloc (si.str_sect);
239 dyninfo_secsize = bfd_get_section_size_before_reloc (si.dyninfo_sect);
240 got_secsize = bfd_get_section_size_before_reloc (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);
250 if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
251 (file_ptr) 0, sym_secsize))
253 if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
254 (file_ptr) 0, str_secsize))
256 if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
257 (file_ptr) 0, dyninfo_secsize))
259 if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
260 (file_ptr) 0, got_secsize))
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))
269 Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p;
272 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
273 if (dyn_tag == DT_NULL)
275 else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
277 if (dt_mips_local_gotno < 0)
279 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
281 else if (dyn_tag == DT_MIPS_GOTSYM)
283 if (dt_mips_gotsym < 0)
285 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
288 if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
291 /* Scan all dynamic symbols and enter them into the minimal symbol table
293 sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
294 stripped = (bfd_get_symcount (abfd) == 0);
296 /* Skip first symbol, which is a null dummy. */
297 for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
304 unsigned char sym_info;
305 unsigned int sym_shndx;
307 enum minimal_symbol_type ms_type;
309 strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
310 if (strx >= str_secsize)
312 name = str_secptr + strx;
313 if (*name == '\0' || *name == '.')
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);
321 if (sym_shndx == SHN_UNDEF)
323 /* Handle undefined functions which are defined in a shared
325 if (ELF_ST_TYPE (sym_info) != STT_FUNC
326 || ELF_ST_BIND (sym_info) != STB_GLOBAL)
329 ms_type = mst_solib_trampoline;
331 /* If sym_value is nonzero, it points to the shared library
332 trampoline entry, which is what we are looking for.
334 If sym_value is zero, then we have to get the GOT entry
336 If the GOT entry is nonzero, it represents the quickstart
337 address of the function and we use that as the symbol value.
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. */
345 int got_entry_offset =
346 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
348 if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
352 (bfd_byte *) (got_secptr + got_entry_offset));
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. */
365 if (sym_shndx == SHN_MIPS_TEXT)
370 ms_type = mst_file_text;
371 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
373 else if (sym_shndx == SHN_MIPS_DATA)
378 ms_type = mst_file_data;
379 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
381 else if (sym_shndx == SHN_MIPS_ACOMMON)
386 ms_type = mst_file_bss;
387 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
389 else if (sym_shndx == SHN_ABS)
399 prim_record_minimal_symbol (name, sym_value, ms_type, objfile);
402 do_cleanups (cleanups);
407 static struct sym_fns ecoff_sym_fns =
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 */
419 _initialize_mipsread (void)
421 add_symtab_fns (&ecoff_sym_fns);