1 /* Read ELF (Executable and Linking Format) object files for GDB.
3 Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 Written by Fred Fish at Cygnus Support.
9 This file is part of GDB.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdb_string.h"
28 #include "elf/common.h"
29 #include "elf/internal.h"
35 #include "stabsread.h"
36 #include "gdb-stabs.h"
37 #include "complaints.h"
40 #include "filenames.h"
44 #include "gdbthread.h"
47 extern void _initialize_elfread (void);
49 /* Forward declarations. */
50 static const struct sym_fns elf_sym_fns_gdb_index
;
51 static const struct sym_fns elf_sym_fns_lazy_psyms
;
53 /* The struct elfinfo is available only during ELF symbol table and
54 psymtab reading. It is destroyed at the completion of psymtab-reading.
55 It's local to elf_symfile_read. */
59 asection
*stabsect
; /* Section pointer for .stab section */
60 asection
*stabindexsect
; /* Section pointer for .stab.index section */
61 asection
*mdebugsect
; /* Section pointer for .mdebug section */
64 static void free_elfinfo (void *);
66 /* Minimal symbols located at the GOT entries for .plt - that is the real
67 pointer where the given entry will jump to. It gets updated by the real
68 function address during lazy ld.so resolving in the inferior. These
69 minimal symbols are indexed for <tab>-completion. */
71 #define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
73 /* Locate the segments in ABFD. */
75 static struct symfile_segment_data
*
76 elf_symfile_segments (bfd
*abfd
)
78 Elf_Internal_Phdr
*phdrs
, **segments
;
80 int num_phdrs
, num_segments
, num_sections
, i
;
82 struct symfile_segment_data
*data
;
84 phdrs_size
= bfd_get_elf_phdr_upper_bound (abfd
);
88 phdrs
= alloca (phdrs_size
);
89 num_phdrs
= bfd_get_elf_phdrs (abfd
, phdrs
);
94 segments
= alloca (sizeof (Elf_Internal_Phdr
*) * num_phdrs
);
95 for (i
= 0; i
< num_phdrs
; i
++)
96 if (phdrs
[i
].p_type
== PT_LOAD
)
97 segments
[num_segments
++] = &phdrs
[i
];
99 if (num_segments
== 0)
102 data
= XZALLOC (struct symfile_segment_data
);
103 data
->num_segments
= num_segments
;
104 data
->segment_bases
= XCALLOC (num_segments
, CORE_ADDR
);
105 data
->segment_sizes
= XCALLOC (num_segments
, CORE_ADDR
);
107 for (i
= 0; i
< num_segments
; i
++)
109 data
->segment_bases
[i
] = segments
[i
]->p_vaddr
;
110 data
->segment_sizes
[i
] = segments
[i
]->p_memsz
;
113 num_sections
= bfd_count_sections (abfd
);
114 data
->segment_info
= XCALLOC (num_sections
, int);
116 for (i
= 0, sect
= abfd
->sections
; sect
!= NULL
; i
++, sect
= sect
->next
)
121 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
124 vma
= bfd_get_section_vma (abfd
, sect
);
126 for (j
= 0; j
< num_segments
; j
++)
127 if (segments
[j
]->p_memsz
> 0
128 && vma
>= segments
[j
]->p_vaddr
129 && (vma
- segments
[j
]->p_vaddr
) < segments
[j
]->p_memsz
)
131 data
->segment_info
[i
] = j
+ 1;
135 /* We should have found a segment for every non-empty section.
136 If we haven't, we will not relocate this section by any
137 offsets we apply to the segments. As an exception, do not
138 warn about SHT_NOBITS sections; in normal ELF execution
139 environments, SHT_NOBITS means zero-initialized and belongs
140 in a segment, but in no-OS environments some tools (e.g. ARM
141 RealView) use SHT_NOBITS for uninitialized data. Since it is
142 uninitialized, it doesn't need a program header. Such
143 binaries are not relocatable. */
144 if (bfd_get_section_size (sect
) > 0 && j
== num_segments
145 && (bfd_get_section_flags (abfd
, sect
) & SEC_LOAD
) != 0)
146 warning (_("Loadable segment \"%s\" outside of ELF segments"),
147 bfd_section_name (abfd
, sect
));
153 /* We are called once per section from elf_symfile_read. We
154 need to examine each section we are passed, check to see
155 if it is something we are interested in processing, and
156 if so, stash away some access information for the section.
158 For now we recognize the dwarf debug information sections and
159 line number sections from matching their section names. The
160 ELF definition is no real help here since it has no direct
161 knowledge of DWARF (by design, so any debugging format can be
164 We also recognize the ".stab" sections used by the Sun compilers
165 released with Solaris 2.
167 FIXME: The section names should not be hardwired strings (what
168 should they be? I don't think most object file formats have enough
169 section flags to specify what kind of debug section it is.
173 elf_locate_sections (bfd
*ignore_abfd
, asection
*sectp
, void *eip
)
177 ei
= (struct elfinfo
*) eip
;
178 if (strcmp (sectp
->name
, ".stab") == 0)
180 ei
->stabsect
= sectp
;
182 else if (strcmp (sectp
->name
, ".stab.index") == 0)
184 ei
->stabindexsect
= sectp
;
186 else if (strcmp (sectp
->name
, ".mdebug") == 0)
188 ei
->mdebugsect
= sectp
;
192 static struct minimal_symbol
*
193 record_minimal_symbol (const char *name
, int name_len
, int copy_name
,
195 enum minimal_symbol_type ms_type
,
196 asection
*bfd_section
, struct objfile
*objfile
)
198 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
200 if (ms_type
== mst_text
|| ms_type
== mst_file_text
201 || ms_type
== mst_text_gnu_ifunc
)
202 address
= gdbarch_smash_text_address (gdbarch
, address
);
204 return prim_record_minimal_symbol_full (name
, name_len
, copy_name
, address
,
205 ms_type
, bfd_section
->index
,
206 bfd_section
, objfile
);
213 elf_symtab_read -- read the symbol table of an ELF file
217 void elf_symtab_read (struct objfile *objfile, int type,
218 long number_of_symbols, asymbol **symbol_table)
222 Given an objfile, a symbol table, and a flag indicating whether the
223 symbol table contains regular, dynamic, or synthetic symbols, add all
224 the global function and data symbols to the minimal symbol table.
226 In stabs-in-ELF, as implemented by Sun, there are some local symbols
227 defined in the ELF symbol table, which can be used to locate
228 the beginnings of sections from each ".o" file that was linked to
229 form the executable objfile. We gather any such info and record it
230 in data structures hung off the objfile's private data.
236 #define ST_SYNTHETIC 2
239 elf_symtab_read (struct objfile
*objfile
, int type
,
240 long number_of_symbols
, asymbol
**symbol_table
,
243 struct gdbarch
*gdbarch
= get_objfile_arch (objfile
);
248 enum minimal_symbol_type ms_type
;
249 /* If sectinfo is nonNULL, it contains section info that should end up
250 filed in the objfile. */
251 struct stab_section_info
*sectinfo
= NULL
;
252 /* If filesym is nonzero, it points to a file symbol, but we haven't
253 seen any section info for it yet. */
254 asymbol
*filesym
= 0;
255 /* Name of filesym. This is either a constant string or is saved on
256 the objfile's obstack. */
257 char *filesymname
= "";
258 struct dbx_symfile_info
*dbx
= objfile
->deprecated_sym_stab_info
;
259 int stripped
= (bfd_get_symcount (objfile
->obfd
) == 0);
260 struct cleanup
*back_to
= make_cleanup (null_cleanup
, NULL
);
262 for (i
= 0; i
< number_of_symbols
; i
++)
264 sym
= symbol_table
[i
];
265 if (sym
->name
== NULL
|| *sym
->name
== '\0')
267 /* Skip names that don't exist (shouldn't happen), or names
268 that are null strings (may happen). */
272 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
273 symbols which do not correspond to objects in the symbol table,
274 but have some other target-specific meaning. */
275 if (bfd_is_target_special_symbol (objfile
->obfd
, sym
))
277 if (gdbarch_record_special_symbol_p (gdbarch
))
278 gdbarch_record_special_symbol (gdbarch
, objfile
, sym
);
282 offset
= ANOFFSET (objfile
->section_offsets
, sym
->section
->index
);
283 if (type
== ST_DYNAMIC
284 && sym
->section
== &bfd_und_section
285 && (sym
->flags
& BSF_FUNCTION
))
287 struct minimal_symbol
*msym
;
288 bfd
*abfd
= objfile
->obfd
;
291 /* Symbol is a reference to a function defined in
293 If its value is non zero then it is usually the address
294 of the corresponding entry in the procedure linkage table,
295 plus the desired section offset.
296 If its value is zero then the dynamic linker has to resolve
297 the symbol. We are unable to find any meaningful address
298 for this symbol in the executable file, so we skip it. */
299 symaddr
= sym
->value
;
303 /* sym->section is the undefined section. However, we want to
304 record the section where the PLT stub resides with the
305 minimal symbol. Search the section table for the one that
306 covers the stub's address. */
307 for (sect
= abfd
->sections
; sect
!= NULL
; sect
= sect
->next
)
309 if ((bfd_get_section_flags (abfd
, sect
) & SEC_ALLOC
) == 0)
312 if (symaddr
>= bfd_get_section_vma (abfd
, sect
)
313 && symaddr
< bfd_get_section_vma (abfd
, sect
)
314 + bfd_get_section_size (sect
))
320 symaddr
+= ANOFFSET (objfile
->section_offsets
, sect
->index
);
322 msym
= record_minimal_symbol
323 (sym
->name
, strlen (sym
->name
), copy_names
,
324 symaddr
, mst_solib_trampoline
, sect
, objfile
);
326 msym
->filename
= filesymname
;
330 /* If it is a nonstripped executable, do not enter dynamic
331 symbols, as the dynamic symbol table is usually a subset
332 of the main symbol table. */
333 if (type
== ST_DYNAMIC
&& !stripped
)
335 if (sym
->flags
& BSF_FILE
)
337 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
338 Chain any old one onto the objfile; remember new sym. */
339 if (sectinfo
!= NULL
)
341 sectinfo
->next
= dbx
->stab_section_info
;
342 dbx
->stab_section_info
= sectinfo
;
347 obsavestring ((char *) filesym
->name
, strlen (filesym
->name
),
348 &objfile
->objfile_obstack
);
350 else if (sym
->flags
& BSF_SECTION_SYM
)
352 else if (sym
->flags
& (BSF_GLOBAL
| BSF_LOCAL
| BSF_WEAK
))
354 struct minimal_symbol
*msym
;
356 /* Select global/local/weak symbols. Note that bfd puts abs
357 symbols in their own section, so all symbols we are
358 interested in will have a section. */
359 /* Bfd symbols are section relative. */
360 symaddr
= sym
->value
+ sym
->section
->vma
;
361 /* Relocate all non-absolute and non-TLS symbols by the
363 if (sym
->section
!= &bfd_abs_section
364 && !(sym
->section
->flags
& SEC_THREAD_LOCAL
))
368 /* For non-absolute symbols, use the type of the section
369 they are relative to, to intuit text/data. Bfd provides
370 no way of figuring this out for absolute symbols. */
371 if (sym
->section
== &bfd_abs_section
)
373 /* This is a hack to get the minimal symbol type
374 right for Irix 5, which has absolute addresses
375 with special section indices for dynamic symbols.
377 NOTE: uweigand-20071112: Synthetic symbols do not
378 have an ELF-private part, so do not touch those. */
379 unsigned int shndx
= type
== ST_SYNTHETIC
? 0 :
380 ((elf_symbol_type
*) sym
)->internal_elf_sym
.st_shndx
;
390 case SHN_MIPS_ACOMMON
:
397 /* If it is an Irix dynamic symbol, skip section name
398 symbols, relocate all others by section offset. */
399 if (ms_type
!= mst_abs
)
401 if (sym
->name
[0] == '.')
406 else if (sym
->section
->flags
& SEC_CODE
)
408 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
410 if (sym
->flags
& BSF_GNU_INDIRECT_FUNCTION
)
411 ms_type
= mst_text_gnu_ifunc
;
415 /* The BSF_SYNTHETIC check is there to omit ppc64 function
416 descriptors mistaken for static functions starting with 'L'.
418 else if ((sym
->name
[0] == '.' && sym
->name
[1] == 'L'
419 && (sym
->flags
& BSF_SYNTHETIC
) == 0)
420 || ((sym
->flags
& BSF_LOCAL
)
421 && sym
->name
[0] == '$'
422 && sym
->name
[1] == 'L'))
423 /* Looks like a compiler-generated label. Skip
424 it. The assembler should be skipping these (to
425 keep executables small), but apparently with
426 gcc on the (deleted) delta m88k SVR4, it loses.
427 So to have us check too should be harmless (but
428 I encourage people to fix this in the assembler
429 instead of adding checks here). */
433 ms_type
= mst_file_text
;
436 else if (sym
->section
->flags
& SEC_ALLOC
)
438 if (sym
->flags
& (BSF_GLOBAL
| BSF_WEAK
))
440 if (sym
->section
->flags
& SEC_LOAD
)
449 else if (sym
->flags
& BSF_LOCAL
)
451 /* Named Local variable in a Data section.
452 Check its name for stabs-in-elf. */
453 int special_local_sect
;
455 if (strcmp ("Bbss.bss", sym
->name
) == 0)
456 special_local_sect
= SECT_OFF_BSS (objfile
);
457 else if (strcmp ("Ddata.data", sym
->name
) == 0)
458 special_local_sect
= SECT_OFF_DATA (objfile
);
459 else if (strcmp ("Drodata.rodata", sym
->name
) == 0)
460 special_local_sect
= SECT_OFF_RODATA (objfile
);
462 special_local_sect
= -1;
463 if (special_local_sect
>= 0)
465 /* Found a special local symbol. Allocate a
466 sectinfo, if needed, and fill it in. */
467 if (sectinfo
== NULL
)
472 max_index
= SECT_OFF_BSS (objfile
);
473 if (objfile
->sect_index_data
> max_index
)
474 max_index
= objfile
->sect_index_data
;
475 if (objfile
->sect_index_rodata
> max_index
)
476 max_index
= objfile
->sect_index_rodata
;
478 /* max_index is the largest index we'll
479 use into this array, so we must
480 allocate max_index+1 elements for it.
481 However, 'struct stab_section_info'
482 already includes one element, so we
483 need to allocate max_index aadditional
485 size
= (sizeof (struct stab_section_info
)
486 + (sizeof (CORE_ADDR
) * max_index
));
487 sectinfo
= (struct stab_section_info
*)
489 make_cleanup (xfree
, sectinfo
);
490 memset (sectinfo
, 0, size
);
491 sectinfo
->num_sections
= max_index
;
494 complaint (&symfile_complaints
,
495 _("elf/stab section information %s "
496 "without a preceding file symbol"),
502 (char *) filesym
->name
;
505 if (sectinfo
->sections
[special_local_sect
] != 0)
506 complaint (&symfile_complaints
,
507 _("duplicated elf/stab section "
508 "information for %s"),
510 /* BFD symbols are section relative. */
511 symaddr
= sym
->value
+ sym
->section
->vma
;
512 /* Relocate non-absolute symbols by the
514 if (sym
->section
!= &bfd_abs_section
)
516 sectinfo
->sections
[special_local_sect
] = symaddr
;
517 /* The special local symbols don't go in the
518 minimal symbol table, so ignore this one. */
521 /* Not a special stabs-in-elf symbol, do regular
522 symbol processing. */
523 if (sym
->section
->flags
& SEC_LOAD
)
525 ms_type
= mst_file_data
;
529 ms_type
= mst_file_bss
;
534 ms_type
= mst_unknown
;
539 /* FIXME: Solaris2 shared libraries include lots of
540 odd "absolute" and "undefined" symbols, that play
541 hob with actions like finding what function the PC
542 is in. Ignore them if they aren't text, data, or bss. */
543 /* ms_type = mst_unknown; */
544 continue; /* Skip this symbol. */
546 msym
= record_minimal_symbol
547 (sym
->name
, strlen (sym
->name
), copy_names
, symaddr
,
548 ms_type
, sym
->section
, objfile
);
552 /* Pass symbol size field in via BFD. FIXME!!! */
553 elf_symbol_type
*elf_sym
;
555 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
556 ELF-private part. However, in some cases (e.g. synthetic
557 'dot' symbols on ppc64) the udata.p entry is set to point back
558 to the original ELF symbol it was derived from. Get the size
560 if (type
!= ST_SYNTHETIC
)
561 elf_sym
= (elf_symbol_type
*) sym
;
563 elf_sym
= (elf_symbol_type
*) sym
->udata
.p
;
566 MSYMBOL_SIZE(msym
) = elf_sym
->internal_elf_sym
.st_size
;
568 msym
->filename
= filesymname
;
569 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, msym
);
572 /* For @plt symbols, also record a trampoline to the
573 destination symbol. The @plt symbol will be used in
574 disassembly, and the trampoline will be used when we are
575 trying to find the target. */
576 if (msym
&& ms_type
== mst_text
&& type
== ST_SYNTHETIC
)
578 int len
= strlen (sym
->name
);
580 if (len
> 4 && strcmp (sym
->name
+ len
- 4, "@plt") == 0)
582 struct minimal_symbol
*mtramp
;
584 mtramp
= record_minimal_symbol (sym
->name
, len
- 4, 1,
586 mst_solib_trampoline
,
587 sym
->section
, objfile
);
590 MSYMBOL_SIZE (mtramp
) = MSYMBOL_SIZE (msym
);
591 mtramp
->filename
= filesymname
;
592 gdbarch_elf_make_msymbol_special (gdbarch
, sym
, mtramp
);
598 do_cleanups (back_to
);
601 /* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
602 for later look ups of which function to call when user requests
603 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
604 library defining `function' we cannot yet know while reading OBJFILE which
605 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
606 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
609 elf_rel_plt_read (struct objfile
*objfile
, asymbol
**dyn_symbol_table
)
611 bfd
*obfd
= objfile
->obfd
;
612 const struct elf_backend_data
*bed
= get_elf_backend_data (obfd
);
613 asection
*plt
, *relplt
, *got_plt
;
616 bfd_size_type reloc_count
, reloc
;
617 char *string_buffer
= NULL
;
618 size_t string_buffer_size
= 0;
619 struct cleanup
*back_to
;
620 struct gdbarch
*gdbarch
= objfile
->gdbarch
;
621 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
622 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
624 if (objfile
->separate_debug_objfile_backlink
)
627 plt
= bfd_get_section_by_name (obfd
, ".plt");
630 plt_elf_idx
= elf_section_data (plt
)->this_idx
;
632 got_plt
= bfd_get_section_by_name (obfd
, ".got.plt");
636 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
637 for (relplt
= obfd
->sections
; relplt
!= NULL
; relplt
= relplt
->next
)
638 if (elf_section_data (relplt
)->this_hdr
.sh_info
== plt_elf_idx
639 && (elf_section_data (relplt
)->this_hdr
.sh_type
== SHT_REL
640 || elf_section_data (relplt
)->this_hdr
.sh_type
== SHT_RELA
))
645 if (! bed
->s
->slurp_reloc_table (obfd
, relplt
, dyn_symbol_table
, TRUE
))
648 back_to
= make_cleanup (free_current_contents
, &string_buffer
);
650 reloc_count
= relplt
->size
/ elf_section_data (relplt
)->this_hdr
.sh_entsize
;
651 for (reloc
= 0; reloc
< reloc_count
; reloc
++)
653 const char *name
, *name_got_plt
;
654 struct minimal_symbol
*msym
;
656 const size_t got_suffix_len
= strlen (SYMBOL_GOT_PLT_SUFFIX
);
659 name
= bfd_asymbol_name (*relplt
->relocation
[reloc
].sym_ptr_ptr
);
660 name_len
= strlen (name
);
661 address
= relplt
->relocation
[reloc
].address
;
663 /* Does the pointer reside in the .got.plt section? */
664 if (!(bfd_get_section_vma (obfd
, got_plt
) <= address
665 && address
< bfd_get_section_vma (obfd
, got_plt
)
666 + bfd_get_section_size (got_plt
)))
669 /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in
670 OBJFILE the symbol is undefined and the objfile having NAME defined
671 may not yet have been loaded. */
673 if (string_buffer_size
< name_len
+ got_suffix_len
)
675 string_buffer_size
= 2 * (name_len
+ got_suffix_len
);
676 string_buffer
= xrealloc (string_buffer
, string_buffer_size
);
678 memcpy (string_buffer
, name
, name_len
);
679 memcpy (&string_buffer
[name_len
], SYMBOL_GOT_PLT_SUFFIX
,
682 msym
= record_minimal_symbol (string_buffer
, name_len
+ got_suffix_len
,
683 1, address
, mst_slot_got_plt
, got_plt
,
686 MSYMBOL_SIZE (msym
) = ptr_size
;
689 do_cleanups (back_to
);
692 /* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
694 static const struct objfile_data
*elf_objfile_gnu_ifunc_cache_data
;
696 /* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
698 struct elf_gnu_ifunc_cache
700 /* This is always a function entry address, not a function descriptor. */
706 /* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
709 elf_gnu_ifunc_cache_hash (const void *a_voidp
)
711 const struct elf_gnu_ifunc_cache
*a
= a_voidp
;
713 return htab_hash_string (a
->name
);
716 /* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
719 elf_gnu_ifunc_cache_eq (const void *a_voidp
, const void *b_voidp
)
721 const struct elf_gnu_ifunc_cache
*a
= a_voidp
;
722 const struct elf_gnu_ifunc_cache
*b
= b_voidp
;
724 return strcmp (a
->name
, b
->name
) == 0;
727 /* Record the target function address of a STT_GNU_IFUNC function NAME is the
728 function entry address ADDR. Return 1 if NAME and ADDR are considered as
729 valid and therefore they were successfully recorded, return 0 otherwise.
731 Function does not expect a duplicate entry. Use
732 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
736 elf_gnu_ifunc_record_cache (const char *name
, CORE_ADDR addr
)
738 struct minimal_symbol
*msym
;
740 struct objfile
*objfile
;
742 struct elf_gnu_ifunc_cache entry_local
, *entry_p
;
745 msym
= lookup_minimal_symbol_by_pc (addr
);
748 if (SYMBOL_VALUE_ADDRESS (msym
) != addr
)
750 /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
751 sect
= SYMBOL_OBJ_SECTION (msym
)->the_bfd_section
;
752 objfile
= SYMBOL_OBJ_SECTION (msym
)->objfile
;
754 /* If .plt jumps back to .plt the symbol is still deferred for later
755 resolution and it has no use for GDB. Besides ".text" this symbol can
756 reside also in ".opd" for ppc64 function descriptor. */
757 if (strcmp (bfd_get_section_name (objfile
->obfd
, sect
), ".plt") == 0)
760 htab
= objfile_data (objfile
, elf_objfile_gnu_ifunc_cache_data
);
763 htab
= htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash
,
764 elf_gnu_ifunc_cache_eq
,
765 NULL
, &objfile
->objfile_obstack
,
766 hashtab_obstack_allocate
,
767 dummy_obstack_deallocate
);
768 set_objfile_data (objfile
, elf_objfile_gnu_ifunc_cache_data
, htab
);
771 entry_local
.addr
= addr
;
772 obstack_grow (&objfile
->objfile_obstack
, &entry_local
,
773 offsetof (struct elf_gnu_ifunc_cache
, name
));
774 obstack_grow_str0 (&objfile
->objfile_obstack
, name
);
775 entry_p
= obstack_finish (&objfile
->objfile_obstack
);
777 slot
= htab_find_slot (htab
, entry_p
, INSERT
);
780 struct elf_gnu_ifunc_cache
*entry_found_p
= *slot
;
781 struct gdbarch
*gdbarch
= objfile
->gdbarch
;
783 if (entry_found_p
->addr
!= addr
)
785 /* This case indicates buggy inferior program, the resolved address
786 should never change. */
788 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
789 "function_address from %s to %s"),
790 name
, paddress (gdbarch
, entry_found_p
->addr
),
791 paddress (gdbarch
, addr
));
794 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
801 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
802 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
803 is not NULL) and the function returns 1. It returns 0 otherwise.
805 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
809 elf_gnu_ifunc_resolve_by_cache (const char *name
, CORE_ADDR
*addr_p
)
811 struct objfile
*objfile
;
813 ALL_PSPACE_OBJFILES (current_program_space
, objfile
)
816 struct elf_gnu_ifunc_cache
*entry_p
;
819 htab
= objfile_data (objfile
, elf_objfile_gnu_ifunc_cache_data
);
823 entry_p
= alloca (sizeof (*entry_p
) + strlen (name
));
824 strcpy (entry_p
->name
, name
);
826 slot
= htab_find_slot (htab
, entry_p
, NO_INSERT
);
830 gdb_assert (entry_p
!= NULL
);
833 *addr_p
= entry_p
->addr
;
840 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
841 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
842 is not NULL) and the function returns 1. It returns 0 otherwise.
844 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
845 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
846 prevent cache entries duplicates. */
849 elf_gnu_ifunc_resolve_by_got (const char *name
, CORE_ADDR
*addr_p
)
852 struct objfile
*objfile
;
853 const size_t got_suffix_len
= strlen (SYMBOL_GOT_PLT_SUFFIX
);
855 name_got_plt
= alloca (strlen (name
) + got_suffix_len
+ 1);
856 sprintf (name_got_plt
, "%s" SYMBOL_GOT_PLT_SUFFIX
, name
);
858 ALL_PSPACE_OBJFILES (current_program_space
, objfile
)
860 bfd
*obfd
= objfile
->obfd
;
861 struct gdbarch
*gdbarch
= objfile
->gdbarch
;
862 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
863 size_t ptr_size
= TYPE_LENGTH (ptr_type
);
864 CORE_ADDR pointer_address
, addr
;
866 gdb_byte
*buf
= alloca (ptr_size
);
867 struct minimal_symbol
*msym
;
869 msym
= lookup_minimal_symbol (name_got_plt
, NULL
, objfile
);
872 if (MSYMBOL_TYPE (msym
) != mst_slot_got_plt
)
874 pointer_address
= SYMBOL_VALUE_ADDRESS (msym
);
876 plt
= bfd_get_section_by_name (obfd
, ".plt");
880 if (MSYMBOL_SIZE (msym
) != ptr_size
)
882 if (target_read_memory (pointer_address
, buf
, ptr_size
) != 0)
884 addr
= extract_typed_address (buf
, ptr_type
);
885 addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, addr
,
890 if (elf_gnu_ifunc_record_cache (name
, addr
))
897 /* Try to find the target resolved function entry address of a STT_GNU_IFUNC
898 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
899 is not NULL) and the function returns 1. It returns 0 otherwise.
901 Both the elf_objfile_gnu_ifunc_cache_data hash table and
902 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
905 elf_gnu_ifunc_resolve_name (const char *name
, CORE_ADDR
*addr_p
)
907 if (elf_gnu_ifunc_resolve_by_cache (name
, addr_p
))
910 if (elf_gnu_ifunc_resolve_by_got (name
, addr_p
))
916 /* Call STT_GNU_IFUNC - a function returning addresss of a real function to
917 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
918 is the entry point of the resolved STT_GNU_IFUNC target function to call.
922 elf_gnu_ifunc_resolve_addr (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
925 CORE_ADDR start_at_pc
, address
;
926 struct type
*func_func_type
= builtin_type (gdbarch
)->builtin_func_func
;
927 struct value
*function
, *address_val
;
929 /* Try first any non-intrusive methods without an inferior call. */
931 if (find_pc_partial_function (pc
, &name_at_pc
, &start_at_pc
, NULL
)
932 && start_at_pc
== pc
)
934 if (elf_gnu_ifunc_resolve_name (name_at_pc
, &address
))
940 function
= allocate_value (func_func_type
);
941 set_value_address (function
, pc
);
943 /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the
944 function entry address. ADDRESS may be a function descriptor. */
946 address_val
= call_function_by_hand (function
, 0, NULL
);
947 address
= value_as_address (address_val
);
948 address
= gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
952 elf_gnu_ifunc_record_cache (name_at_pc
, address
);
957 /* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
960 elf_gnu_ifunc_resolver_stop (struct breakpoint
*b
)
962 struct breakpoint
*b_return
;
963 struct frame_info
*prev_frame
= get_prev_frame (get_current_frame ());
964 struct frame_id prev_frame_id
= get_stack_frame_id (prev_frame
);
965 CORE_ADDR prev_pc
= get_frame_pc (prev_frame
);
966 int thread_id
= pid_to_thread_id (inferior_ptid
);
968 gdb_assert (b
->type
== bp_gnu_ifunc_resolver
);
970 for (b_return
= b
->related_breakpoint
; b_return
!= b
;
971 b_return
= b_return
->related_breakpoint
)
973 gdb_assert (b_return
->type
== bp_gnu_ifunc_resolver_return
);
974 gdb_assert (b_return
->loc
!= NULL
&& b_return
->loc
->next
== NULL
);
975 gdb_assert (frame_id_p (b_return
->frame_id
));
977 if (b_return
->thread
== thread_id
978 && b_return
->loc
->requested_address
== prev_pc
979 && frame_id_eq (b_return
->frame_id
, prev_frame_id
))
985 struct symtab_and_line sal
;
987 /* No need to call find_pc_line for symbols resolving as this is only
988 a helper breakpointer never shown to the user. */
991 sal
.pspace
= current_inferior ()->pspace
;
993 sal
.section
= find_pc_overlay (sal
.pc
);
995 b_return
= set_momentary_breakpoint (get_frame_arch (prev_frame
), sal
,
997 bp_gnu_ifunc_resolver_return
);
999 /* Add new b_return to the ring list b->related_breakpoint. */
1000 gdb_assert (b_return
->related_breakpoint
== b_return
);
1001 b_return
->related_breakpoint
= b
->related_breakpoint
;
1002 b
->related_breakpoint
= b_return
;
1006 /* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
1009 elf_gnu_ifunc_resolver_return_stop (struct breakpoint
*b
)
1011 struct gdbarch
*gdbarch
= get_frame_arch (get_current_frame ());
1012 struct type
*func_func_type
= builtin_type (gdbarch
)->builtin_func_func
;
1013 struct type
*value_type
= TYPE_TARGET_TYPE (func_func_type
);
1014 struct regcache
*regcache
= get_thread_regcache (inferior_ptid
);
1015 struct value
*value
;
1016 CORE_ADDR resolved_address
, resolved_pc
;
1017 struct symtab_and_line sal
;
1018 struct symtabs_and_lines sals
, sals_end
;
1020 gdb_assert (b
->type
== bp_gnu_ifunc_resolver_return
);
1022 value
= allocate_value (value_type
);
1023 gdbarch_return_value (gdbarch
, func_func_type
, value_type
, regcache
,
1024 value_contents_raw (value
), NULL
);
1025 resolved_address
= value_as_address (value
);
1026 resolved_pc
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
1030 while (b
->related_breakpoint
!= b
)
1032 struct breakpoint
*b_next
= b
->related_breakpoint
;
1036 case bp_gnu_ifunc_resolver
:
1038 case bp_gnu_ifunc_resolver_return
:
1039 delete_breakpoint (b
);
1042 internal_error (__FILE__
, __LINE__
,
1043 _("handle_inferior_event: Invalid "
1044 "gnu-indirect-function breakpoint type %d"),
1049 gdb_assert (b
->type
== bp_gnu_ifunc_resolver
);
1051 gdb_assert (current_program_space
== b
->pspace
);
1052 elf_gnu_ifunc_record_cache (b
->addr_string
, resolved_pc
);
1054 sal
= find_pc_line (resolved_pc
, 0);
1059 b
->type
= bp_breakpoint
;
1060 update_breakpoint_locations (b
, sals
, sals_end
);
1069 /* Locate NT_GNU_BUILD_ID from ABFD and return its content. */
1071 static struct build_id
*
1072 build_id_bfd_get (bfd
*abfd
)
1074 struct build_id
*retval
;
1076 if (!bfd_check_format (abfd
, bfd_object
)
1077 || bfd_get_flavour (abfd
) != bfd_target_elf_flavour
1078 || elf_tdata (abfd
)->build_id
== NULL
)
1081 retval
= xmalloc (sizeof *retval
- 1 + elf_tdata (abfd
)->build_id_size
);
1082 retval
->size
= elf_tdata (abfd
)->build_id_size
;
1083 memcpy (retval
->data
, elf_tdata (abfd
)->build_id
, retval
->size
);
1088 /* Return if FILENAME has NT_GNU_BUILD_ID matching the CHECK value. */
1091 build_id_verify (const char *filename
, struct build_id
*check
)
1094 struct build_id
*found
= NULL
;
1097 /* We expect to be silent on the non-existing files. */
1098 abfd
= bfd_open_maybe_remote (filename
);
1102 found
= build_id_bfd_get (abfd
);
1105 warning (_("File \"%s\" has no build-id, file skipped"), filename
);
1106 else if (found
->size
!= check
->size
1107 || memcmp (found
->data
, check
->data
, found
->size
) != 0)
1108 warning (_("File \"%s\" has a different build-id, file skipped"),
1113 gdb_bfd_close_or_warn (abfd
);
1121 build_id_to_debug_filename (struct build_id
*build_id
)
1123 char *link
, *debugdir
, *retval
= NULL
;
1125 /* DEBUG_FILE_DIRECTORY/.build-id/ab/cdef */
1126 link
= alloca (strlen (debug_file_directory
) + (sizeof "/.build-id/" - 1) + 1
1127 + 2 * build_id
->size
+ (sizeof ".debug" - 1) + 1);
1129 /* Keep backward compatibility so that DEBUG_FILE_DIRECTORY being "" will
1130 cause "/.build-id/..." lookups. */
1132 debugdir
= debug_file_directory
;
1135 char *s
, *debugdir_end
;
1136 gdb_byte
*data
= build_id
->data
;
1137 size_t size
= build_id
->size
;
1139 while (*debugdir
== DIRNAME_SEPARATOR
)
1142 debugdir_end
= strchr (debugdir
, DIRNAME_SEPARATOR
);
1143 if (debugdir_end
== NULL
)
1144 debugdir_end
= &debugdir
[strlen (debugdir
)];
1146 memcpy (link
, debugdir
, debugdir_end
- debugdir
);
1147 s
= &link
[debugdir_end
- debugdir
];
1148 s
+= sprintf (s
, "/.build-id/");
1152 s
+= sprintf (s
, "%02x", (unsigned) *data
++);
1157 s
+= sprintf (s
, "%02x", (unsigned) *data
++);
1158 strcpy (s
, ".debug");
1160 /* lrealpath() is expensive even for the usually non-existent files. */
1161 if (access (link
, F_OK
) == 0)
1162 retval
= lrealpath (link
);
1164 if (retval
!= NULL
&& !build_id_verify (retval
, build_id
))
1173 debugdir
= debugdir_end
;
1175 while (*debugdir
!= 0);
1181 find_separate_debug_file_by_buildid (struct objfile
*objfile
)
1183 struct build_id
*build_id
;
1185 build_id
= build_id_bfd_get (objfile
->obfd
);
1186 if (build_id
!= NULL
)
1188 char *build_id_name
;
1190 build_id_name
= build_id_to_debug_filename (build_id
);
1192 /* Prevent looping on a stripped .debug file. */
1193 if (build_id_name
!= NULL
1194 && filename_cmp (build_id_name
, objfile
->name
) == 0)
1196 warning (_("\"%s\": separate debug info file has no debug info"),
1198 xfree (build_id_name
);
1200 else if (build_id_name
!= NULL
)
1201 return build_id_name
;
1206 /* Scan and build partial symbols for a symbol file.
1207 We have been initialized by a call to elf_symfile_init, which
1208 currently does nothing.
1210 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
1211 in each section. We simplify it down to a single offset for all
1214 This function only does the minimum work necessary for letting the
1215 user "name" things symbolically; it does not read the entire symtab.
1216 Instead, it reads the external and static symbols and puts them in partial
1217 symbol tables. When more extensive information is requested of a
1218 file, the corresponding partial symbol table is mutated into a full
1219 fledged symbol table by going back and reading the symbols
1222 We look for sections with specific names, to tell us what debug
1223 format to look for: FIXME!!!
1225 elfstab_build_psymtabs() handles STABS symbols;
1226 mdebug_build_psymtabs() handles ECOFF debugging information.
1228 Note that ELF files have a "minimal" symbol table, which looks a lot
1229 like a COFF symbol table, but has only the minimal information necessary
1230 for linking. We process this also, and use the information to
1231 build gdb's minimal symbol table. This gives us some minimal debugging
1232 capability even for files compiled without -g. */
1235 elf_symfile_read (struct objfile
*objfile
, int symfile_flags
)
1237 bfd
*synth_abfd
, *abfd
= objfile
->obfd
;
1239 struct cleanup
*back_to
;
1240 long symcount
= 0, dynsymcount
= 0, synthcount
, storage_needed
;
1241 asymbol
**symbol_table
= NULL
, **dyn_symbol_table
= NULL
;
1244 init_minimal_symbol_collection ();
1245 back_to
= make_cleanup_discard_minimal_symbols ();
1247 memset ((char *) &ei
, 0, sizeof (ei
));
1249 /* Allocate struct to keep track of the symfile. */
1250 objfile
->deprecated_sym_stab_info
= (struct dbx_symfile_info
*)
1251 xmalloc (sizeof (struct dbx_symfile_info
));
1252 memset ((char *) objfile
->deprecated_sym_stab_info
,
1253 0, sizeof (struct dbx_symfile_info
));
1254 make_cleanup (free_elfinfo
, (void *) objfile
);
1256 /* Process the normal ELF symbol table first. This may write some
1257 chain of info into the dbx_symfile_info in
1258 objfile->deprecated_sym_stab_info, which can later be used by
1259 elfstab_offset_sections. */
1261 storage_needed
= bfd_get_symtab_upper_bound (objfile
->obfd
);
1262 if (storage_needed
< 0)
1263 error (_("Can't read symbols from %s: %s"),
1264 bfd_get_filename (objfile
->obfd
),
1265 bfd_errmsg (bfd_get_error ()));
1267 if (storage_needed
> 0)
1269 symbol_table
= (asymbol
**) xmalloc (storage_needed
);
1270 make_cleanup (xfree
, symbol_table
);
1271 symcount
= bfd_canonicalize_symtab (objfile
->obfd
, symbol_table
);
1274 error (_("Can't read symbols from %s: %s"),
1275 bfd_get_filename (objfile
->obfd
),
1276 bfd_errmsg (bfd_get_error ()));
1278 elf_symtab_read (objfile
, ST_REGULAR
, symcount
, symbol_table
, 0);
1281 /* Add the dynamic symbols. */
1283 storage_needed
= bfd_get_dynamic_symtab_upper_bound (objfile
->obfd
);
1285 if (storage_needed
> 0)
1287 /* Memory gets permanently referenced from ABFD after
1288 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1289 It happens only in the case when elf_slurp_reloc_table sees
1290 asection->relocation NULL. Determining which section is asection is
1291 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1292 implementation detail, though. */
1294 dyn_symbol_table
= bfd_alloc (abfd
, storage_needed
);
1295 dynsymcount
= bfd_canonicalize_dynamic_symtab (objfile
->obfd
,
1298 if (dynsymcount
< 0)
1299 error (_("Can't read symbols from %s: %s"),
1300 bfd_get_filename (objfile
->obfd
),
1301 bfd_errmsg (bfd_get_error ()));
1303 elf_symtab_read (objfile
, ST_DYNAMIC
, dynsymcount
, dyn_symbol_table
, 0);
1305 elf_rel_plt_read (objfile
, dyn_symbol_table
);
1308 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
1309 elfutils (eu-strip) moves even the .symtab section into the .debug file.
1311 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
1312 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
1313 address. But with eu-strip files bfd_get_synthetic_symtab would fail to
1314 read the code address from .opd while it reads the .symtab section from
1315 a separate debug info file as the .opd section is SHT_NOBITS there.
1317 With SYNTH_ABFD the .opd section will be read from the original
1318 backlinked binary where it is valid. */
1320 if (objfile
->separate_debug_objfile_backlink
)
1321 synth_abfd
= objfile
->separate_debug_objfile_backlink
->obfd
;
1325 /* Add synthetic symbols - for instance, names for any PLT entries. */
1327 synthcount
= bfd_get_synthetic_symtab (synth_abfd
, symcount
, symbol_table
,
1328 dynsymcount
, dyn_symbol_table
,
1332 asymbol
**synth_symbol_table
;
1335 make_cleanup (xfree
, synthsyms
);
1336 synth_symbol_table
= xmalloc (sizeof (asymbol
*) * synthcount
);
1337 for (i
= 0; i
< synthcount
; i
++)
1338 synth_symbol_table
[i
] = synthsyms
+ i
;
1339 make_cleanup (xfree
, synth_symbol_table
);
1340 elf_symtab_read (objfile
, ST_SYNTHETIC
, synthcount
,
1341 synth_symbol_table
, 1);
1344 /* Install any minimal symbols that have been collected as the current
1345 minimal symbols for this objfile. The debug readers below this point
1346 should not generate new minimal symbols; if they do it's their
1347 responsibility to install them. "mdebug" appears to be the only one
1348 which will do this. */
1350 install_minimal_symbols (objfile
);
1351 do_cleanups (back_to
);
1353 /* Now process debugging information, which is contained in
1354 special ELF sections. */
1356 /* We first have to find them... */
1357 bfd_map_over_sections (abfd
, elf_locate_sections
, (void *) & ei
);
1359 /* ELF debugging information is inserted into the psymtab in the
1360 order of least informative first - most informative last. Since
1361 the psymtab table is searched `most recent insertion first' this
1362 increases the probability that more detailed debug information
1363 for a section is found.
1365 For instance, an object file might contain both .mdebug (XCOFF)
1366 and .debug_info (DWARF2) sections then .mdebug is inserted first
1367 (searched last) and DWARF2 is inserted last (searched first). If
1368 we don't do this then the XCOFF info is found first - for code in
1369 an included file XCOFF info is useless. */
1373 const struct ecoff_debug_swap
*swap
;
1375 /* .mdebug section, presumably holding ECOFF debugging
1377 swap
= get_elf_backend_data (abfd
)->elf_backend_ecoff_debug_swap
;
1379 elfmdebug_build_psymtabs (objfile
, swap
, ei
.mdebugsect
);
1385 /* Stab sections have an associated string table that looks like
1386 a separate section. */
1387 str_sect
= bfd_get_section_by_name (abfd
, ".stabstr");
1389 /* FIXME should probably warn about a stab section without a stabstr. */
1391 elfstab_build_psymtabs (objfile
,
1394 bfd_section_size (abfd
, str_sect
));
1397 if (dwarf2_has_info (objfile
))
1399 /* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF debug
1400 information present in OBJFILE. If there is such debug info present
1401 never use .gdb_index. */
1403 if (!objfile_has_partial_symbols (objfile
)
1404 && dwarf2_initialize_objfile (objfile
))
1405 objfile
->sf
= &elf_sym_fns_gdb_index
;
1408 /* It is ok to do this even if the stabs reader made some
1409 partial symbols, because OBJF_PSYMTABS_READ has not been
1410 set, and so our lazy reader function will still be called
1412 objfile
->sf
= &elf_sym_fns_lazy_psyms
;
1415 /* If the file has its own symbol tables it has no separate debug
1416 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1417 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
1418 `.note.gnu.build-id'. */
1419 else if (!objfile_has_partial_symbols (objfile
))
1423 debugfile
= find_separate_debug_file_by_buildid (objfile
);
1425 if (debugfile
== NULL
)
1426 debugfile
= find_separate_debug_file_by_debuglink (objfile
);
1430 bfd
*abfd
= symfile_bfd_open (debugfile
);
1432 symbol_file_add_separate (abfd
, symfile_flags
, objfile
);
1438 /* Callback to lazily read psymtabs. */
1441 read_psyms (struct objfile
*objfile
)
1443 if (dwarf2_has_info (objfile
))
1444 dwarf2_build_psymtabs (objfile
);
1447 /* This cleans up the objfile's deprecated_sym_stab_info pointer, and
1448 the chain of stab_section_info's, that might be dangling from
1452 free_elfinfo (void *objp
)
1454 struct objfile
*objfile
= (struct objfile
*) objp
;
1455 struct dbx_symfile_info
*dbxinfo
= objfile
->deprecated_sym_stab_info
;
1456 struct stab_section_info
*ssi
, *nssi
;
1458 ssi
= dbxinfo
->stab_section_info
;
1466 dbxinfo
->stab_section_info
= 0; /* Just say No mo info about this. */
1470 /* Initialize anything that needs initializing when a completely new symbol
1471 file is specified (not just adding some symbols from another file, e.g. a
1474 We reinitialize buildsym, since we may be reading stabs from an ELF
1478 elf_new_init (struct objfile
*ignore
)
1480 stabsread_new_init ();
1481 buildsym_new_init ();
1484 /* Perform any local cleanups required when we are done with a particular
1485 objfile. I.E, we are in the process of discarding all symbol information
1486 for an objfile, freeing up all memory held for it, and unlinking the
1487 objfile struct from the global list of known objfiles. */
1490 elf_symfile_finish (struct objfile
*objfile
)
1492 if (objfile
->deprecated_sym_stab_info
!= NULL
)
1494 xfree (objfile
->deprecated_sym_stab_info
);
1497 dwarf2_free_objfile (objfile
);
1500 /* ELF specific initialization routine for reading symbols.
1502 It is passed a pointer to a struct sym_fns which contains, among other
1503 things, the BFD for the file whose symbols are being read, and a slot for
1504 a pointer to "private data" which we can fill with goodies.
1506 For now at least, we have nothing in particular to do, so this function is
1510 elf_symfile_init (struct objfile
*objfile
)
1512 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1513 find this causes a significant slowdown in gdb then we could
1514 set it in the debug symbol readers only when necessary. */
1515 objfile
->flags
|= OBJF_REORDERED
;
1518 /* When handling an ELF file that contains Sun STABS debug info,
1519 some of the debug info is relative to the particular chunk of the
1520 section that was generated in its individual .o file. E.g.
1521 offsets to static variables are relative to the start of the data
1522 segment *for that module before linking*. This information is
1523 painfully squirreled away in the ELF symbol table as local symbols
1524 with wierd names. Go get 'em when needed. */
1527 elfstab_offset_sections (struct objfile
*objfile
, struct partial_symtab
*pst
)
1529 const char *filename
= pst
->filename
;
1530 struct dbx_symfile_info
*dbx
= objfile
->deprecated_sym_stab_info
;
1531 struct stab_section_info
*maybe
= dbx
->stab_section_info
;
1532 struct stab_section_info
*questionable
= 0;
1535 /* The ELF symbol info doesn't include path names, so strip the path
1536 (if any) from the psymtab filename. */
1537 filename
= lbasename (filename
);
1539 /* FIXME: This linear search could speed up significantly
1540 if it was chained in the right order to match how we search it,
1541 and if we unchained when we found a match. */
1542 for (; maybe
; maybe
= maybe
->next
)
1544 if (filename
[0] == maybe
->filename
[0]
1545 && filename_cmp (filename
, maybe
->filename
) == 0)
1547 /* We found a match. But there might be several source files
1548 (from different directories) with the same name. */
1549 if (0 == maybe
->found
)
1551 questionable
= maybe
; /* Might use it later. */
1555 if (maybe
== 0 && questionable
!= 0)
1557 complaint (&symfile_complaints
,
1558 _("elf/stab section information questionable for %s"),
1560 maybe
= questionable
;
1565 /* Found it! Allocate a new psymtab struct, and fill it in. */
1567 pst
->section_offsets
= (struct section_offsets
*)
1568 obstack_alloc (&objfile
->objfile_obstack
,
1569 SIZEOF_N_SECTION_OFFSETS (objfile
->num_sections
));
1570 for (i
= 0; i
< maybe
->num_sections
; i
++)
1571 (pst
->section_offsets
)->offsets
[i
] = maybe
->sections
[i
];
1575 /* We were unable to find any offsets for this file. Complain. */
1576 if (dbx
->stab_section_info
) /* If there *is* any info, */
1577 complaint (&symfile_complaints
,
1578 _("elf/stab section information missing for %s"), filename
);
1581 /* Register that we are able to handle ELF object file formats. */
1583 static const struct sym_fns elf_sym_fns
=
1585 bfd_target_elf_flavour
,
1586 elf_new_init
, /* init anything gbl to entire symtab */
1587 elf_symfile_init
, /* read initial info, setup for sym_read() */
1588 elf_symfile_read
, /* read a symbol file into symtab */
1589 NULL
, /* sym_read_psymbols */
1590 elf_symfile_finish
, /* finished with file, cleanup */
1591 default_symfile_offsets
, /* Translate ext. to int. relocation */
1592 elf_symfile_segments
, /* Get segment information from a file. */
1594 default_symfile_relocate
, /* Relocate a debug section. */
1598 /* The same as elf_sym_fns, but not registered and lazily reads
1601 static const struct sym_fns elf_sym_fns_lazy_psyms
=
1603 bfd_target_elf_flavour
,
1604 elf_new_init
, /* init anything gbl to entire symtab */
1605 elf_symfile_init
, /* read initial info, setup for sym_read() */
1606 elf_symfile_read
, /* read a symbol file into symtab */
1607 read_psyms
, /* sym_read_psymbols */
1608 elf_symfile_finish
, /* finished with file, cleanup */
1609 default_symfile_offsets
, /* Translate ext. to int. relocation */
1610 elf_symfile_segments
, /* Get segment information from a file. */
1612 default_symfile_relocate
, /* Relocate a debug section. */
1616 /* The same as elf_sym_fns, but not registered and uses the
1617 DWARF-specific GNU index rather than psymtab. */
1618 static const struct sym_fns elf_sym_fns_gdb_index
=
1620 bfd_target_elf_flavour
,
1621 elf_new_init
, /* init anything gbl to entire symab */
1622 elf_symfile_init
, /* read initial info, setup for sym_red() */
1623 elf_symfile_read
, /* read a symbol file into symtab */
1624 NULL
, /* sym_read_psymbols */
1625 elf_symfile_finish
, /* finished with file, cleanup */
1626 default_symfile_offsets
, /* Translate ext. to int. relocatin */
1627 elf_symfile_segments
, /* Get segment information from a file. */
1629 default_symfile_relocate
, /* Relocate a debug section. */
1630 &dwarf2_gdb_index_functions
1633 /* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1635 static const struct gnu_ifunc_fns elf_gnu_ifunc_fns
=
1637 elf_gnu_ifunc_resolve_addr
,
1638 elf_gnu_ifunc_resolve_name
,
1639 elf_gnu_ifunc_resolver_stop
,
1640 elf_gnu_ifunc_resolver_return_stop
1644 _initialize_elfread (void)
1646 add_symtab_fns (&elf_sym_fns
);
1648 elf_objfile_gnu_ifunc_cache_data
= register_objfile_data ();
1649 gnu_ifunc_fns_p
= &elf_gnu_ifunc_fns
;