configure clean up patch from Steve Ellcey.
[external/binutils.git] / gdb / mipsread.c
1 /* Read a symbol table in MIPS' format (Third-Eye).
2
3    Copyright 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4    1998, 1999, 2000, 2001, 2003, 2004
5    Free Software Foundation, Inc.
6
7    Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU.  Major work
8    by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
9
10    This file is part of GDB.
11
12    This program is free software; you can redistribute it and/or modify
13    it under the terms of the GNU General Public License as published by
14    the Free Software Foundation; either version 2 of the License, or
15    (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20    GNU General Public License for more details.
21
22    You should have received a copy of the GNU General Public License
23    along with this program; if not, write to the Free Software
24    Foundation, Inc., 59 Temple Place - Suite 330,
25    Boston, MA 02111-1307, USA.  */
26
27 /* Read symbols from an ECOFF file.  Most of the work is done in
28    mdebugread.c.  */
29
30 #include "defs.h"
31 #include "gdb_string.h"
32 #include "bfd.h"
33 #include "symtab.h"
34 #include "objfiles.h"
35 #include "buildsym.h"
36 #include "stabsread.h"
37
38 #include "coff/sym.h"
39 #include "coff/internal.h"
40 #include "coff/ecoff.h"
41 #include "libcoff.h"            /* Private BFD COFF information.  */
42 #include "libecoff.h"           /* Private BFD ECOFF information.  */
43 #include "elf/common.h"
44 #include "elf/mips.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 mainline)
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 (free, sym_secptr);
222   str_secptr = xmalloc (str_secsize);
223   make_cleanup (free, str_secptr);
224   dyninfo_secptr = xmalloc (dyninfo_secsize);
225   make_cleanup (free, dyninfo_secptr);
226   got_secptr = xmalloc (got_secsize);
227   make_cleanup (free, 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 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       isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
299
300       if (sym_shndx == SHN_UNDEF)
301         {
302           /* Handle undefined functions which are defined in a shared
303              library.  */
304           if (ELF_ST_TYPE (sym_info) != STT_FUNC
305               || ELF_ST_BIND (sym_info) != STB_GLOBAL)
306             continue;
307
308           ms_type = mst_solib_trampoline;
309
310           /* If sym_value is nonzero, it points to the shared library
311              trampoline entry, which is what we are looking for.
312
313              If sym_value is zero, then we have to get the GOT entry
314              for the symbol.
315
316              If the GOT entry is nonzero, it represents the quickstart
317              address of the function and we use that as the symbol
318              value.
319
320              If the GOT entry is zero, the function address has to be
321              resolved by the runtime loader before the executable is
322              started.  We are unable to find any meaningful address
323              for these functions in the executable file, so we skip
324              them.  */
325           if (sym_value == 0)
326             {
327               int got_entry_offset =
328                 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
329
330               if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
331                 continue;
332               sym_value =
333                 bfd_h_get_64 (abfd,
334                               (bfd_byte *) (got_secptr + got_entry_offset));
335               if (sym_value == 0)
336                 continue;
337             }
338         }
339       else
340         {
341           /* Symbols defined in the executable itself. We only care
342              about them if this is a stripped executable, otherwise
343              they have been retrieved from the normal symbol table
344              already.  */
345           if (!stripped)
346             continue;
347
348           if (sym_shndx == SHN_MIPS_TEXT)
349             {
350               if (isglobal)
351                 ms_type = mst_text;
352               else
353                 ms_type = mst_file_text;
354               sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
355             }
356           else if (sym_shndx == SHN_MIPS_DATA)
357             {
358               if (isglobal)
359                 ms_type = mst_data;
360               else
361                 ms_type = mst_file_data;
362               sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
363             }
364           else if (sym_shndx == SHN_MIPS_ACOMMON)
365             {
366               if (isglobal)
367                 ms_type = mst_bss;
368               else
369                 ms_type = mst_file_bss;
370               sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
371             }
372           else if (sym_shndx == SHN_ABS)
373             {
374               ms_type = mst_abs;
375             }
376           else
377             {
378               continue;
379             }
380         }
381
382       prim_record_minimal_symbol (name, sym_value, ms_type, objfile);
383     }
384
385   do_cleanups (cleanups);
386 }
387
388 /* Initialization.  */
389
390 static struct sym_fns ecoff_sym_fns =
391 {
392   bfd_target_ecoff_flavour,
393   mipscoff_new_init,            /* sym_new_init: init anything gbl to entire symtab */
394   mipscoff_symfile_init,        /* sym_init: read initial info, setup for sym_read() */
395   mipscoff_symfile_read,        /* sym_read: read a symbol file into symtab */
396   mipscoff_symfile_finish,      /* sym_finish: finished with file, cleanup */
397   default_symfile_offsets,      /* sym_offsets: dummy FIXME til implem sym reloc */
398   NULL                          /* next: pointer to next struct sym_fns */
399 };
400
401 /* Provide a prototype to silence -Wmissing-prototypes.  */
402 void _initialize_mipsread (void);
403
404 void
405 _initialize_mipsread (void)
406 {
407   add_symtab_fns (&ecoff_sym_fns);
408 }