]> Git Repo - binutils.git/blob - gdb/elfread.c
* ser-mac.c (mac_close): Change a typo SetSetBuf to SerSetBuf.
[binutils.git] / gdb / elfread.c
1 /* Read ELF (Executable and Linking Format) object files for GDB.
2    Copyright 1991, 1992, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
3    Written by Fred Fish at Cygnus Support.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 #include "defs.h"
22 #include "bfd.h"
23 #include "gdb_string.h"
24 #include "elf-bfd.h"
25 #include "elf/mips.h"
26 #include "symtab.h"
27 #include "symfile.h"
28 #include "objfiles.h"
29 #include "buildsym.h"
30 #include "stabsread.h"
31 #include "gdb-stabs.h"
32 #include "complaints.h"
33 #include "demangle.h"
34
35 /* The struct elfinfo is available only during ELF symbol table and
36    psymtab reading.  It is destroyed at the complation of psymtab-reading.
37    It's local to elf_symfile_read.  */
38
39 struct elfinfo {
40   file_ptr dboffset;            /* Offset to dwarf debug section */
41   unsigned int dbsize;          /* Size of dwarf debug section */
42   file_ptr lnoffset;            /* Offset to dwarf line number section */
43   unsigned int lnsize;          /* Size of dwarf line number section */
44   asection *stabsect;           /* Section pointer for .stab section */
45   asection *stabindexsect;      /* Section pointer for .stab.index section */
46   asection *mdebugsect;         /* Section pointer for .mdebug section */
47 };
48
49 /* Various things we might complain about... */
50
51 struct complaint section_info_complaint = 
52   {"elf/stab section information %s without a preceding file symbol", 0, 0};
53
54 struct complaint section_info_dup_complaint = 
55   {"duplicated elf/stab section information for %s", 0, 0};
56
57 struct complaint stab_info_mismatch_complaint = 
58   {"elf/stab section information missing for %s", 0, 0};
59
60 struct complaint stab_info_questionable_complaint = 
61   {"elf/stab section information questionable for %s", 0, 0};
62
63 static void
64 elf_symfile_init PARAMS ((struct objfile *));
65
66 static void
67 elf_new_init PARAMS ((struct objfile *));
68
69 static void
70 elf_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
71
72 static void
73 elf_symfile_finish PARAMS ((struct objfile *));
74
75 static void
76 elf_symtab_read PARAMS ((bfd *,  CORE_ADDR, struct objfile *, int));
77
78 static void
79 free_elfinfo PARAMS ((void *));
80
81 static struct minimal_symbol *
82 record_minimal_symbol_and_info PARAMS ((char *, CORE_ADDR,
83                                         enum minimal_symbol_type, char *,
84                                         struct objfile *));
85
86 static void
87 elf_locate_sections PARAMS ((bfd *, asection *, void *));
88
89 /* We are called once per section from elf_symfile_read.  We
90    need to examine each section we are passed, check to see
91    if it is something we are interested in processing, and
92    if so, stash away some access information for the section.
93
94    For now we recognize the dwarf debug information sections and
95    line number sections from matching their section names.  The
96    ELF definition is no real help here since it has no direct
97    knowledge of DWARF (by design, so any debugging format can be
98    used).
99
100    We also recognize the ".stab" sections used by the Sun compilers
101    released with Solaris 2.
102
103    FIXME: The section names should not be hardwired strings (what
104    should they be?  I don't think most object file formats have enough
105    section flags to specify what kind of debug section it is
106    -kingdon).  */
107
108 static void
109 elf_locate_sections (ignore_abfd, sectp, eip)
110      bfd *ignore_abfd;
111      asection *sectp;
112      PTR eip;
113 {
114   register struct elfinfo *ei;
115
116   ei = (struct elfinfo *) eip;
117   if (STREQ (sectp -> name, ".debug"))
118     {
119       ei -> dboffset = sectp -> filepos;
120       ei -> dbsize = bfd_get_section_size_before_reloc (sectp);
121     }
122   else if (STREQ (sectp -> name, ".line"))
123     {
124       ei -> lnoffset = sectp -> filepos;
125       ei -> lnsize = bfd_get_section_size_before_reloc (sectp);
126     }
127   else if (STREQ (sectp -> name, ".stab"))
128     {
129       ei -> stabsect = sectp;
130     }
131   else if (STREQ (sectp -> name, ".stab.index"))
132     {
133       ei -> stabindexsect = sectp;
134     }
135   else if (STREQ (sectp -> name, ".mdebug"))
136     {
137       ei -> mdebugsect = sectp;
138     }
139 }
140
141 #if 0   /* Currently unused */
142
143 char *
144 elf_interpreter (abfd)
145      bfd *abfd;
146 {
147   sec_ptr interp_sec;
148   unsigned size;
149   char *interp = NULL;
150
151   interp_sec = bfd_get_section_by_name (abfd, ".interp");
152   if (interp_sec)
153     {
154       size = bfd_section_size (abfd, interp_sec);
155       interp = alloca (size);
156       if (bfd_get_section_contents (abfd, interp_sec, interp, (file_ptr)0,
157                                     size))
158         {
159           interp = savestring (interp, size - 1);
160         }
161       else
162         {
163           interp = NULL;
164         }
165     }
166   return (interp);
167 }
168
169 #endif
170
171 static struct minimal_symbol *
172 record_minimal_symbol_and_info (name, address, ms_type, info, objfile)
173      char *name;
174      CORE_ADDR address;
175      enum minimal_symbol_type ms_type;
176      char *info;                /* FIXME, is this really char *? */
177      struct objfile *objfile;
178 {
179   int section;
180
181   /* Guess the section from the type.  This is likely to be wrong in
182      some cases.  */
183   switch (ms_type)
184     {
185     case mst_text:
186     case mst_file_text:
187       section = SECT_OFF_TEXT;
188 #ifdef SMASH_TEXT_ADDRESS
189       SMASH_TEXT_ADDRESS (address);
190 #endif
191       break;
192     case mst_data:
193     case mst_file_data:
194       section = SECT_OFF_DATA;
195       break;
196     case mst_bss:
197     case mst_file_bss:
198       section = SECT_OFF_BSS;
199       break;
200     default:
201       section = -1;
202       break;
203     }
204
205   return prim_record_minimal_symbol_and_info
206     (name, address, ms_type, info, section, objfile);
207 }
208
209 /*
210
211 LOCAL FUNCTION
212
213         elf_symtab_read -- read the symbol table of an ELF file
214
215 SYNOPSIS
216
217         void elf_symtab_read (bfd *abfd, CORE_ADDR addr,
218                               struct objfile *objfile, int dynamic)
219
220 DESCRIPTION
221
222         Given an open bfd, a base address to relocate symbols to, and a
223         flag that specifies whether or not this bfd is for an executable
224         or not (may be shared library for example), add all the global
225         function and data symbols to the minimal symbol table.
226
227         In stabs-in-ELF, as implemented by Sun, there are some local symbols
228         defined in the ELF symbol table, which can be used to locate
229         the beginnings of sections from each ".o" file that was linked to
230         form the executable objfile.  We gather any such info and record it
231         in data structures hung off the objfile's private data.
232
233 */
234
235 static void
236 elf_symtab_read (abfd, addr, objfile, dynamic)
237      bfd *abfd;
238      CORE_ADDR addr;
239      struct objfile *objfile;
240      int dynamic;
241 {
242   long storage_needed;
243   asymbol *sym;
244   asymbol **symbol_table;
245   long number_of_symbols;
246   long i;
247   int index;
248   struct cleanup *back_to;
249   CORE_ADDR symaddr;
250   enum minimal_symbol_type ms_type;
251   /* If sectinfo is nonNULL, it contains section info that should end up
252      filed in the objfile.  */
253   struct stab_section_info *sectinfo = NULL;
254   /* If filesym is nonzero, it points to a file symbol, but we haven't
255      seen any section info for it yet.  */
256   asymbol *filesym = 0;
257 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
258   /* Name of filesym, as saved on the symbol_obstack.  */
259   char *filesymname = obsavestring ("", 0, &objfile->symbol_obstack);
260 #endif
261   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
262                                  objfile->sym_stab_info;
263   unsigned long size;
264   int stripped = (bfd_get_symcount (abfd) == 0);
265  
266   if (dynamic)
267     {
268       storage_needed = bfd_get_dynamic_symtab_upper_bound (abfd);
269
270       /* Nothing to be done if there is no dynamic symtab.  */
271       if (storage_needed < 0)
272         return;
273     }
274   else
275     {
276       storage_needed = bfd_get_symtab_upper_bound (abfd);
277       if (storage_needed < 0)
278         error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
279                bfd_errmsg (bfd_get_error ()));
280     }
281   if (storage_needed > 0)
282     {
283       symbol_table = (asymbol **) xmalloc (storage_needed);
284       back_to = make_cleanup (free, symbol_table);
285       if (dynamic)
286         number_of_symbols = bfd_canonicalize_dynamic_symtab (abfd,
287                                                              symbol_table);
288       else
289         number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
290       if (number_of_symbols < 0)
291         error ("Can't read symbols from %s: %s", bfd_get_filename (abfd),
292                bfd_errmsg (bfd_get_error ()));
293       for (i = 0; i < number_of_symbols; i++)
294         {
295           sym = symbol_table[i];
296           if (sym -> name == NULL || *sym -> name == '\0')
297             {
298               /* Skip names that don't exist (shouldn't happen), or names
299                  that are null strings (may happen). */
300               continue;
301             }
302
303           if (dynamic
304               && sym -> section == &bfd_und_section
305               && (sym -> flags & BSF_FUNCTION))
306             {
307               struct minimal_symbol *msym;
308
309               /* Symbol is a reference to a function defined in
310                  a shared library.
311                  If its value is non zero then it is usually the address
312                  of the corresponding entry in the procedure linkage table,
313                  relative to the base address.
314                  If its value is zero then the dynamic linker has to resolve
315                  the symbol. We are unable to find any meaningful address
316                  for this symbol in the executable file, so we skip it.  */
317               symaddr = sym -> value;
318               if (symaddr == 0)
319                 continue;
320               symaddr += addr;
321               msym = record_minimal_symbol_and_info
322                 ((char *) sym -> name, symaddr,
323                 mst_solib_trampoline, NULL, objfile);
324 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
325               if (msym != NULL)
326                 msym->filename = filesymname;
327 #endif
328               continue;
329             }
330
331           /* If it is a nonstripped executable, do not enter dynamic
332              symbols, as the dynamic symbol table is usually a subset
333              of the main symbol table.  */
334           if (dynamic && !stripped)
335             continue;
336           if (sym -> flags & BSF_FILE)
337             {
338               /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
339                  Chain any old one onto the objfile; remember new sym.  */
340               if (sectinfo != NULL)
341                 {
342                   sectinfo -> next = dbx -> stab_section_info;
343                   dbx -> stab_section_info = sectinfo;
344                   sectinfo = NULL;
345                 }
346               filesym = sym;
347 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
348               filesymname =
349                 obsavestring ((char *)filesym->name, strlen (filesym->name),
350                               &objfile->symbol_obstack);
351 #endif
352             }
353           else if (sym -> flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
354             {
355               struct minimal_symbol *msym;
356
357               /* Select global/local/weak symbols.  Note that bfd puts abs
358                  symbols in their own section, so all symbols we are
359                  interested in will have a section. */
360               /* Bfd symbols are section relative. */
361               symaddr = sym -> value + sym -> section -> vma;
362               /* Relocate all non-absolute symbols by base address.  */
363               if (sym -> section != &bfd_abs_section)
364                 {
365                   symaddr += addr;
366                 }
367               /* For non-absolute symbols, use the type of the section
368                  they are relative to, to intuit text/data.  Bfd provides
369                  no way of figuring this out for absolute symbols. */
370               if (sym -> section == &bfd_abs_section)
371                 {
372                   /* This is a hack to get the minimal symbol type
373                      right for Irix 5, which has absolute adresses
374                      with special section indices for dynamic symbols. */
375                   unsigned short shndx =
376                     ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
377
378                   switch (shndx)
379                     {
380                     case SHN_MIPS_TEXT:
381                       ms_type = mst_text;
382                       break;
383                     case SHN_MIPS_DATA:
384                       ms_type = mst_data;
385                       break;
386                     case SHN_MIPS_ACOMMON:
387                       ms_type = mst_bss;
388                       break;
389                     default:
390                       ms_type = mst_abs;
391                     }
392                 }
393               else if (sym -> section -> flags & SEC_CODE)
394                 {
395                   if (sym -> flags & BSF_GLOBAL)
396                     {
397                       ms_type = mst_text;
398                     }
399                   else if ((sym->name[0] == '.' && sym->name[1] == 'L')
400                            || ((sym -> flags & BSF_LOCAL)
401                                && sym->name[0] == '$'
402                                && sym->name[1] == 'L'))
403                     /* Looks like a compiler-generated label.  Skip it.
404                        The assembler should be skipping these (to keep
405                        executables small), but apparently with gcc on the
406                        delta m88k SVR4, it loses.  So to have us check too
407                        should be harmless (but I encourage people to fix this
408                        in the assembler instead of adding checks here).  */
409                     continue;
410                   else
411                     {
412                       ms_type = mst_file_text;
413                     }
414                 }
415               else if (sym -> section -> flags & SEC_ALLOC)
416                 {
417                   if (sym -> flags & BSF_GLOBAL)
418                     {
419                       if (sym -> section -> flags & SEC_LOAD)
420                         {
421                           ms_type = mst_data;
422                         }
423                       else
424                         {
425                           ms_type = mst_bss;
426                         }
427                     }
428                   else if (sym -> flags & BSF_LOCAL)
429                     {
430                       /* Named Local variable in a Data section.  Check its
431                          name for stabs-in-elf.  The STREQ macro checks the
432                          first character inline, so we only actually do a
433                          strcmp function call on names that start with 'B'
434                          or 'D' */
435                       index = SECT_OFF_MAX;
436                       if (STREQ ("Bbss.bss", sym -> name))
437                         {
438                           index = SECT_OFF_BSS;
439                         }
440                       else if (STREQ ("Ddata.data", sym -> name))
441                         {
442                           index = SECT_OFF_DATA;
443                         }
444                       else if (STREQ ("Drodata.rodata", sym -> name))
445                         {
446                           index = SECT_OFF_RODATA;
447                         }
448                       if (index != SECT_OFF_MAX)
449                         {
450                           /* Found a special local symbol.  Allocate a
451                              sectinfo, if needed, and fill it in.  */
452                           if (sectinfo == NULL)
453                             {
454                               sectinfo = (struct stab_section_info *)
455                                 xmmalloc (objfile -> md, sizeof (*sectinfo));
456                               memset ((PTR) sectinfo, 0, sizeof (*sectinfo));
457                               if (filesym == NULL)
458                                 {
459                                   complain (&section_info_complaint,
460                                             sym -> name);
461                                 }
462                               else
463                                 {
464                                   sectinfo -> filename =
465                                     (char *) filesym -> name;
466                                 }
467                             }
468                           if (sectinfo -> sections[index] != 0)
469                             {
470                               complain (&section_info_dup_complaint,
471                                         sectinfo -> filename);
472                             }
473                           /* Bfd symbols are section relative. */
474                           symaddr = sym -> value + sym -> section -> vma;
475                           /* Relocate non-absolute symbols by base address.  */
476                           if (sym -> section != &bfd_abs_section)
477                             {
478                               symaddr += addr;
479                             }
480                           sectinfo -> sections[index] = symaddr;
481                           /* The special local symbols don't go in the
482                              minimal symbol table, so ignore this one. */
483                           continue;
484                         }
485                       /* Not a special stabs-in-elf symbol, do regular
486                          symbol processing. */
487                       if (sym -> section -> flags & SEC_LOAD)
488                         {
489                           ms_type = mst_file_data;
490                         }
491                       else
492                         {
493                           ms_type = mst_file_bss;
494                         }
495                     }
496                   else
497                     {
498                       ms_type = mst_unknown;
499                     }
500                 }
501               else
502                 {
503                   /* FIXME:  Solaris2 shared libraries include lots of
504                      odd "absolute" and "undefined" symbols, that play 
505                      hob with actions like finding what function the PC
506                      is in.  Ignore them if they aren't text, data, or bss.  */
507                   /* ms_type = mst_unknown; */
508                   continue;             /* Skip this symbol. */
509                 }
510               /* Pass symbol size field in via BFD.  FIXME!!!  */
511               size = ((elf_symbol_type *) sym) -> internal_elf_sym.st_size;
512               msym = record_minimal_symbol_and_info
513                 ((char *) sym -> name, symaddr,
514                  ms_type, (PTR) size, objfile);
515 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
516               if (msym != NULL)
517                 msym->filename = filesymname;
518 #endif
519             }
520         }
521       do_cleanups (back_to);
522     }
523 }
524
525 /* Scan and build partial symbols for a symbol file.
526    We have been initialized by a call to elf_symfile_init, which 
527    currently does nothing.
528
529    SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
530    in each section.  We simplify it down to a single offset for all
531    symbols.  FIXME.
532
533    MAINLINE is true if we are reading the main symbol
534    table (as opposed to a shared lib or dynamically loaded file).
535
536    This function only does the minimum work necessary for letting the
537    user "name" things symbolically; it does not read the entire symtab.
538    Instead, it reads the external and static symbols and puts them in partial
539    symbol tables.  When more extensive information is requested of a
540    file, the corresponding partial symbol table is mutated into a full
541    fledged symbol table by going back and reading the symbols
542    for real.
543
544    We look for sections with specific names, to tell us what debug
545    format to look for:  FIXME!!!
546
547    dwarf_build_psymtabs() builds psymtabs for DWARF symbols;
548    elfstab_build_psymtabs() handles STABS symbols;
549    mdebug_build_psymtabs() handles ECOFF debugging information.
550
551    Note that ELF files have a "minimal" symbol table, which looks a lot
552    like a COFF symbol table, but has only the minimal information necessary
553    for linking.  We process this also, and use the information to
554    build gdb's minimal symbol table.  This gives us some minimal debugging
555    capability even for files compiled without -g.  */
556
557 static void
558 elf_symfile_read (objfile, section_offsets, mainline)
559      struct objfile *objfile;
560      struct section_offsets *section_offsets;
561      int mainline;
562 {
563   bfd *abfd = objfile->obfd;
564   struct elfinfo ei;
565   struct cleanup *back_to;
566   CORE_ADDR offset;
567
568   init_minimal_symbol_collection ();
569   back_to = make_cleanup (discard_minimal_symbols, 0);
570
571   memset ((char *) &ei, 0, sizeof (ei));
572
573   /* Allocate struct to keep track of the symfile */
574   objfile->sym_stab_info = (PTR)
575     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
576   memset ((char *) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
577   make_cleanup (free_elfinfo, (PTR) objfile);
578
579   /* Process the normal ELF symbol table first.  This may write some 
580      chain of info into the dbx_symfile_info in objfile->sym_stab_info,
581      which can later be used by elfstab_offset_sections.  */
582
583   /* FIXME, should take a section_offsets param, not just an offset.  */
584   offset = ANOFFSET (section_offsets, 0);
585   elf_symtab_read (abfd, offset, objfile, 0);
586
587   /* Add the dynamic symbols.  */
588
589   elf_symtab_read (abfd, offset, objfile, 1);
590
591   /* Now process debugging information, which is contained in
592      special ELF sections.  We first have to find them... */
593
594   bfd_map_over_sections (abfd, elf_locate_sections, (PTR) &ei);
595   if (ei.dboffset && ei.lnoffset)
596     {
597       /* DWARF sections */
598       dwarf_build_psymtabs (objfile,
599                             section_offsets, mainline,
600                             ei.dboffset, ei.dbsize,
601                             ei.lnoffset, ei.lnsize);
602     }
603   if (ei.stabsect)
604     {
605       asection *str_sect;
606
607       /* Stab sections have an associated string table that looks like
608          a separate section.  */
609       str_sect = bfd_get_section_by_name (abfd, ".stabstr");
610
611       /* FIXME should probably warn about a stab section without a stabstr.  */
612       if (str_sect)
613         elfstab_build_psymtabs (objfile,
614                                 section_offsets,
615                                 mainline,
616                                 ei.stabsect->filepos,
617                                 bfd_section_size (abfd, ei.stabsect),
618                                 str_sect->filepos,
619                                 bfd_section_size (abfd, str_sect));
620     }
621   if (ei.mdebugsect)
622     {
623       const struct ecoff_debug_swap *swap;
624
625       /* .mdebug section, presumably holding ECOFF debugging
626          information.  */
627       swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
628       if (swap)
629         elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect,
630                                   section_offsets);
631     }
632
633   /* Install any minimal symbols that have been collected as the current
634      minimal symbols for this objfile. */
635
636   install_minimal_symbols (objfile);
637
638   do_cleanups (back_to);
639 }
640
641 /* This cleans up the objfile's sym_stab_info pointer, and the chain of
642    stab_section_info's, that might be dangling from it.  */
643
644 static void
645 free_elfinfo (objp)
646      PTR objp;
647 {
648   struct objfile *objfile = (struct objfile *)objp;
649   struct dbx_symfile_info *dbxinfo = (struct dbx_symfile_info *)
650                                      objfile->sym_stab_info;
651   struct stab_section_info *ssi, *nssi;
652
653   ssi = dbxinfo->stab_section_info;
654   while (ssi)
655     {
656       nssi = ssi->next;
657       mfree (objfile->md, ssi);
658       ssi = nssi;
659     }
660
661   dbxinfo->stab_section_info = 0;       /* Just say No mo info about this.  */
662 }
663
664
665 /* Initialize anything that needs initializing when a completely new symbol
666    file is specified (not just adding some symbols from another file, e.g. a
667    shared library).
668
669    We reinitialize buildsym, since we may be reading stabs from an ELF file.  */
670
671 static void
672 elf_new_init (ignore)
673      struct objfile *ignore;
674 {
675   stabsread_new_init ();
676   buildsym_new_init ();
677 }
678
679 /* Perform any local cleanups required when we are done with a particular
680    objfile.  I.E, we are in the process of discarding all symbol information
681    for an objfile, freeing up all memory held for it, and unlinking the
682    objfile struct from the global list of known objfiles. */
683
684 static void
685 elf_symfile_finish (objfile)
686      struct objfile *objfile;
687 {
688   if (objfile -> sym_stab_info != NULL)
689     {
690       mfree (objfile -> md, objfile -> sym_stab_info);
691     }
692 }
693
694 /* ELF specific initialization routine for reading symbols.
695
696    It is passed a pointer to a struct sym_fns which contains, among other
697    things, the BFD for the file whose symbols are being read, and a slot for
698    a pointer to "private data" which we can fill with goodies.
699
700    For now at least, we have nothing in particular to do, so this function is
701    just a stub. */
702
703 static void
704 elf_symfile_init (objfile)
705      struct objfile *objfile;
706 {
707   /* ELF objects may be reordered, so set OBJF_REORDERED.  If we
708      find this causes a significant slowdown in gdb then we could
709      set it in the debug symbol readers only when necessary.  */
710   objfile->flags |= OBJF_REORDERED;
711 }
712
713 /* When handling an ELF file that contains Sun STABS debug info,
714    some of the debug info is relative to the particular chunk of the
715    section that was generated in its individual .o file.  E.g.
716    offsets to static variables are relative to the start of the data
717    segment *for that module before linking*.  This information is
718    painfully squirreled away in the ELF symbol table as local symbols
719    with wierd names.  Go get 'em when needed.  */
720
721 void
722 elfstab_offset_sections (objfile, pst)
723      struct objfile *objfile;
724      struct partial_symtab *pst;
725 {
726   char *filename = pst->filename;
727   struct dbx_symfile_info *dbx = (struct dbx_symfile_info *)
728                                  objfile->sym_stab_info;
729   struct stab_section_info *maybe = dbx->stab_section_info;
730   struct stab_section_info *questionable = 0;
731   int i;
732   char *p;
733
734   /* The ELF symbol info doesn't include path names, so strip the path
735      (if any) from the psymtab filename.  */
736   while (0 != (p = strchr (filename, '/')))
737     filename = p+1;
738
739   /* FIXME:  This linear search could speed up significantly
740      if it was chained in the right order to match how we search it,
741      and if we unchained when we found a match. */
742   for (; maybe; maybe = maybe->next)
743     {
744       if (filename[0] == maybe->filename[0]
745           && STREQ (filename, maybe->filename))
746         {
747           /* We found a match.  But there might be several source files
748              (from different directories) with the same name.  */
749           if (0 == maybe->found)
750             break;
751           questionable = maybe;         /* Might use it later.  */
752         }
753     }
754
755   if (maybe == 0 && questionable != 0)
756     {
757       complain (&stab_info_questionable_complaint, filename);
758       maybe = questionable;
759     }
760
761   if (maybe)
762     {
763       /* Found it!  Allocate a new psymtab struct, and fill it in.  */
764       maybe->found++;
765       pst->section_offsets = (struct section_offsets *)
766         obstack_alloc (&objfile -> psymbol_obstack,
767                        sizeof (struct section_offsets) +
768                sizeof (pst->section_offsets->offsets) * (SECT_OFF_MAX-1));
769
770       for (i = 0; i < SECT_OFF_MAX; i++)
771         ANOFFSET (pst->section_offsets, i) = maybe->sections[i];
772       return;
773     }
774
775   /* We were unable to find any offsets for this file.  Complain.  */
776   if (dbx->stab_section_info)           /* If there *is* any info, */
777     complain (&stab_info_mismatch_complaint, filename);
778 }
779 \f
780 /* Register that we are able to handle ELF object file formats.  */
781
782 static struct sym_fns elf_sym_fns =
783 {
784   bfd_target_elf_flavour,
785   elf_new_init,         /* sym_new_init: init anything gbl to entire symtab */
786   elf_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
787   elf_symfile_read,     /* sym_read: read a symbol file into symtab */
788   elf_symfile_finish,   /* sym_finish: finished with file, cleanup */
789   default_symfile_offsets,
790                         /* sym_offsets:  Translate ext. to int. relocation */
791   NULL                  /* next: pointer to next struct sym_fns */
792 };
793
794 void
795 _initialize_elfread ()
796 {
797   add_symtab_fns (&elf_sym_fns);
798 }
This page took 0.068423 seconds and 4 git commands to generate.