1 /* Read a symbol table in MIPS' format (Third-Eye).
2 Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996
3 Free Software Foundation, Inc.
4 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work
5 by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* Read symbols from an ECOFF file. Most of the work is done in
27 #include "gdb_string.h"
33 #include "stabsread.h"
34 #include "gdb-stabs.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"
45 mipscoff_new_init PARAMS ((struct objfile *));
48 mipscoff_symfile_init PARAMS ((struct objfile *));
51 mipscoff_symfile_read PARAMS ((struct objfile *, struct section_offsets *,
55 mipscoff_symfile_finish PARAMS ((struct objfile *));
57 static struct section_offsets *
58 mipscoff_symfile_offsets PARAMS ((struct objfile *, CORE_ADDR));
61 read_alphacoff_dynamic_symtab PARAMS ((struct section_offsets *,
62 struct objfile *objfile));
64 /* Initialize anything that needs initializing when a completely new
65 symbol file is specified (not just adding some symbols from another
66 file, e.g. a shared library). */
68 extern CORE_ADDR sigtramp_address;
71 mipscoff_new_init (ignore)
72 struct objfile *ignore;
75 stabsread_new_init ();
79 /* Initialize to read a symbol file (nothing to do). */
82 mipscoff_symfile_init (objfile)
83 struct objfile *objfile;
87 /* Read a symbol file from a file. */
90 mipscoff_symfile_read (objfile, section_offsets, mainline)
91 struct objfile *objfile;
92 struct section_offsets *section_offsets;
95 bfd *abfd = objfile->obfd;
96 struct cleanup * back_to;
98 init_minimal_symbol_collection ();
99 back_to = make_cleanup (discard_minimal_symbols, 0);
101 /* Now that the executable file is positioned at symbol table,
102 process it and define symbols accordingly. */
104 if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info)
105 (abfd, (asection *) NULL, &ecoff_data (abfd)->debug_info)))
106 error ("Error reading symbol table: %s", bfd_errmsg (bfd_get_error ()));
108 mdebug_build_psymtabs (objfile, &ecoff_backend (abfd)->debug_swap,
109 &ecoff_data (abfd)->debug_info, section_offsets);
111 /* Add alpha coff dynamic symbols. */
113 read_alphacoff_dynamic_symtab (section_offsets, objfile);
115 /* Install any minimal symbols that have been collected as the current
116 minimal symbols for this objfile. */
118 install_minimal_symbols (objfile);
120 /* If the entry_file bounds are still unknown after processing the
121 partial symbols, then try to set them from the minimal symbols
122 surrounding the entry_point. */
125 && objfile->ei.entry_point != INVALID_ENTRY_POINT
126 && objfile->ei.entry_file_lowpc == INVALID_ENTRY_LOWPC)
128 struct minimal_symbol *m;
130 m = lookup_minimal_symbol_by_pc (objfile->ei.entry_point);
131 if (m && SYMBOL_NAME (m + 1))
133 objfile->ei.entry_file_lowpc = SYMBOL_VALUE_ADDRESS (m);
134 objfile->ei.entry_file_highpc = SYMBOL_VALUE_ADDRESS (m + 1);
138 do_cleanups (back_to);
141 /* Perform any local cleanups required when we are done with a
142 particular objfile. */
145 mipscoff_symfile_finish (objfile)
146 struct objfile *objfile;
150 /* Fake up identical offsets for all sections. */
152 static struct section_offsets *
153 mipscoff_symfile_offsets (objfile, addr)
154 struct objfile *objfile;
157 struct section_offsets *section_offsets;
160 objfile->num_sections = SECT_OFF_MAX;
161 section_offsets = ((struct section_offsets *)
162 obstack_alloc (&objfile->psymbol_obstack,
163 (sizeof (struct section_offsets)
164 + (sizeof (section_offsets->offsets)
165 * (SECT_OFF_MAX - 1)))));
167 for (i = 0; i < SECT_OFF_MAX; i++)
168 ANOFFSET (section_offsets, i) = addr;
170 return section_offsets;
173 /* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
174 standard coff section. The ELF format for the symbols differs from
175 the format defined in elf/external.h. It seems that a normal ELF 32 bit
176 format is used, and the representation only changes because longs are
177 64 bit on the alpha. In addition, the handling of text/data section
178 indices for symbols is different from the ELF ABI.
179 As the BFD linker currently does not support dynamic linking on the alpha,
180 there seems to be no reason to pollute BFD with another mixture of object
181 file formats for now. */
183 /* Format of an alpha external ELF symbol. */
186 unsigned char st_name[4]; /* Symbol name, index in string tbl */
187 unsigned char st_pad[4]; /* Pad to long word boundary */
188 unsigned char st_value[8]; /* Value of the symbol */
189 unsigned char st_size[4]; /* Associated symbol size */
190 unsigned char st_info[1]; /* Type and binding attributes */
191 unsigned char st_other[1]; /* No defined meaning, 0 */
192 unsigned char st_shndx[2]; /* Associated section index */
193 } Elfalpha_External_Sym;
195 /* Format of an alpha external ELF dynamic info structure. */
198 unsigned char d_tag[4]; /* Tag */
199 unsigned char d_pad[4]; /* Pad to long word boundary */
201 unsigned char d_ptr[8]; /* Pointer value */
202 unsigned char d_val[4]; /* Integer value */
204 } Elfalpha_External_Dyn;
206 /* Struct to obtain the section pointers for alpha dynamic symbol info. */
208 struct alphacoff_dynsecinfo {
209 asection *sym_sect; /* Section pointer for .dynsym section */
210 asection *str_sect; /* Section pointer for .dynstr section */
211 asection *dyninfo_sect; /* Section pointer for .dynamic section */
212 asection *got_sect; /* Section pointer for .got section */
216 alphacoff_locate_sections PARAMS ((bfd *, asection *, void *));
218 /* We are called once per section from read_alphacoff_dynamic_symtab.
219 We need to examine each section we are passed, check to see
220 if it is something we are interested in processing, and
221 if so, stash away some access information for the section. */
224 alphacoff_locate_sections (ignore_abfd, sectp, sip)
229 register struct alphacoff_dynsecinfo *si;
231 si = (struct alphacoff_dynsecinfo *) sip;
233 if (STREQ (sectp->name, ".dynsym"))
235 si->sym_sect = sectp;
237 else if (STREQ (sectp->name, ".dynstr"))
239 si->str_sect = sectp;
241 else if (STREQ (sectp->name, ".dynamic"))
243 si->dyninfo_sect = sectp;
245 else if (STREQ (sectp->name, ".got"))
247 si->got_sect = sectp;
251 /* Scan an alpha dynamic symbol table for symbols of interest and
252 add them to the minimal symbol table. */
255 read_alphacoff_dynamic_symtab (section_offsets, objfile)
256 struct section_offsets *section_offsets;
257 struct objfile *objfile;
259 bfd *abfd = objfile->obfd;
260 struct alphacoff_dynsecinfo si;
263 char *dyninfo_secptr;
265 bfd_size_type sym_secsize;
266 bfd_size_type str_secsize;
267 bfd_size_type dyninfo_secsize;
268 bfd_size_type got_secsize;
272 Elfalpha_External_Sym *x_symp;
275 int got_entry_size = 8;
276 int dt_mips_local_gotno = -1;
277 int dt_mips_gotsym = -1;
280 /* We currently only know how to handle alpha dynamic symbols. */
281 if (bfd_get_arch (abfd) != bfd_arch_alpha)
284 /* Locate the dynamic symbols sections and read them in. */
285 memset ((char *) &si, 0, sizeof (si));
286 bfd_map_over_sections (abfd, alphacoff_locate_sections, (PTR) &si);
287 if (si.sym_sect == NULL
288 || si.str_sect == NULL
289 || si.dyninfo_sect == NULL
290 || si.got_sect == NULL)
293 sym_secsize = bfd_get_section_size_before_reloc (si.sym_sect);
294 str_secsize = bfd_get_section_size_before_reloc (si.str_sect);
295 dyninfo_secsize = bfd_get_section_size_before_reloc (si.dyninfo_sect);
296 got_secsize = bfd_get_section_size_before_reloc (si.got_sect);
297 sym_secptr = alloca (sym_secsize);
298 str_secptr = alloca (str_secsize);
299 dyninfo_secptr = alloca (dyninfo_secsize);
300 got_secptr = alloca (got_secsize);
302 if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
303 (file_ptr)0, sym_secsize))
305 if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
306 (file_ptr)0, str_secsize))
308 if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
309 (file_ptr)0, dyninfo_secsize))
311 if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
312 (file_ptr)0, got_secsize))
315 /* Find the number of local GOT entries and the index for the
316 the first dynamic symbol in the GOT. */
317 for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize;
318 dyninfo_p < dyninfo_end;
319 dyninfo_p += sizeof (Elfalpha_External_Dyn))
321 Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *)dyninfo_p;
324 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
325 if (dyn_tag == DT_NULL)
327 else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
329 if (dt_mips_local_gotno < 0)
331 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
333 else if (dyn_tag == DT_MIPS_GOTSYM)
335 if (dt_mips_gotsym < 0)
337 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
340 if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
343 /* Scan all dynamic symbols and enter them into the minimal symbol table
345 sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
346 stripped = (bfd_get_symcount (abfd) == 0);
348 /* Skip first symbol, which is a null dummy. */
349 for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
356 unsigned char sym_info;
357 unsigned int sym_shndx;
359 enum minimal_symbol_type ms_type;
361 strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
362 if (strx >= str_secsize)
364 name = str_secptr + strx;
365 if (*name == '\0' || *name == '.')
368 sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
369 sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
370 sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
371 isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
373 if (sym_shndx == SHN_UNDEF)
375 /* Handle undefined functions which are defined in a shared
377 if (ELF_ST_TYPE (sym_info) != STT_FUNC
378 || ELF_ST_BIND (sym_info) != STB_GLOBAL)
381 ms_type = mst_solib_trampoline;
383 /* If sym_value is nonzero, it points to the shared library
384 trampoline entry, which is what we are looking for.
386 If sym_value is zero, then we have to get the GOT entry
388 If the GOT entry is nonzero, it represents the quickstart
389 address of the function and we use that as the symbol value.
391 If the GOT entry is zero, the function address has to be resolved
392 by the runtime loader before the executable is started.
393 We are unable to find any meaningful address for these
394 functions in the executable file, so we skip them. */
397 int got_entry_offset =
398 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
400 if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
404 (bfd_byte *) (got_secptr + got_entry_offset));
411 /* Symbols defined in the executable itself. We only care about
412 them if this is a stripped executable, otherwise they have
413 been retrieved from the normal symbol table already. */
417 if (sym_shndx == SHN_MIPS_TEXT)
422 ms_type = mst_file_text;
423 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
425 else if (sym_shndx == SHN_MIPS_DATA)
430 ms_type = mst_file_data;
431 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
433 else if (sym_shndx == SHN_MIPS_ACOMMON)
438 ms_type = mst_file_bss;
439 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
441 else if (sym_shndx == SHN_ABS)
451 prim_record_minimal_symbol (obsavestring (name,
453 &objfile -> symbol_obstack),
462 static struct sym_fns ecoff_sym_fns =
464 bfd_target_ecoff_flavour,
465 mipscoff_new_init, /* sym_new_init: init anything gbl to entire symtab */
466 mipscoff_symfile_init, /* sym_init: read initial info, setup for sym_read() */
467 mipscoff_symfile_read, /* sym_read: read a symbol file into symtab */
468 mipscoff_symfile_finish, /* sym_finish: finished with file, cleanup */
469 mipscoff_symfile_offsets, /* sym_offsets: dummy FIXME til implem sym reloc */
470 NULL /* next: pointer to next struct sym_fns */
474 _initialize_mipsread ()
476 add_symtab_fns (&ecoff_sym_fns);