Rename "set/show remotebaud" command into "set/show serial baud"
[deliverable/binutils-gdb.git] / gdb / elfread.c
CommitLineData
c906108c 1/* Read ELF (Executable and Linking Format) object files for GDB.
1bac305b 2
28e7fd62 3 Copyright (C) 1991-2013 Free Software Foundation, Inc.
1bac305b 4
c906108c
SS
5 Written by Fred Fish at Cygnus Support.
6
c5aa993b 7 This file is part of GDB.
c906108c 8
c5aa993b
JM
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
a9762ec7 11 the Free Software Foundation; either version 3 of the License, or
c5aa993b 12 (at your option) any later version.
c906108c 13
c5aa993b
JM
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
c906108c 18
c5aa993b 19 You should have received a copy of the GNU General Public License
a9762ec7 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c
SS
21
22#include "defs.h"
23#include "bfd.h"
24#include "gdb_string.h"
25#include "elf-bfd.h"
31d99776
DJ
26#include "elf/common.h"
27#include "elf/internal.h"
c906108c
SS
28#include "elf/mips.h"
29#include "symtab.h"
30#include "symfile.h"
31#include "objfiles.h"
32#include "buildsym.h"
33#include "stabsread.h"
34#include "gdb-stabs.h"
35#include "complaints.h"
36#include "demangle.h"
ccefe4c4 37#include "psympriv.h"
0ba1096a 38#include "filenames.h"
55aa24fb
SDJ
39#include "probe.h"
40#include "arch-utils.h"
07be84bf
JK
41#include "gdbtypes.h"
42#include "value.h"
43#include "infcall.h"
0e30163f
JK
44#include "gdbthread.h"
45#include "regcache.h"
0af1e9a5 46#include "bcache.h"
cbb099e8 47#include "gdb_bfd.h"
dc294be5 48#include "build-id.h"
c906108c 49
a14ed312 50extern void _initialize_elfread (void);
392a587b 51
b11896a5 52/* Forward declarations. */
00b5771c 53static const struct sym_fns elf_sym_fns_gdb_index;
b11896a5 54static const struct sym_fns elf_sym_fns_lazy_psyms;
9291a0cd 55
c906108c 56/* The struct elfinfo is available only during ELF symbol table and
6426a772 57 psymtab reading. It is destroyed at the completion of psymtab-reading.
c906108c
SS
58 It's local to elf_symfile_read. */
59
c5aa993b
JM
60struct elfinfo
61 {
c5aa993b
JM
62 asection *stabsect; /* Section pointer for .stab section */
63 asection *stabindexsect; /* Section pointer for .stab.index section */
64 asection *mdebugsect; /* Section pointer for .mdebug section */
65 };
c906108c 66
55aa24fb
SDJ
67/* Per-objfile data for probe info. */
68
69static const struct objfile_data *probe_key = NULL;
70
12b9c64f 71static void free_elfinfo (void *);
c906108c 72
07be84bf
JK
73/* Minimal symbols located at the GOT entries for .plt - that is the real
74 pointer where the given entry will jump to. It gets updated by the real
75 function address during lazy ld.so resolving in the inferior. These
76 minimal symbols are indexed for <tab>-completion. */
77
78#define SYMBOL_GOT_PLT_SUFFIX "@got.plt"
79
31d99776
DJ
80/* Locate the segments in ABFD. */
81
82static struct symfile_segment_data *
83elf_symfile_segments (bfd *abfd)
84{
85 Elf_Internal_Phdr *phdrs, **segments;
86 long phdrs_size;
87 int num_phdrs, num_segments, num_sections, i;
88 asection *sect;
89 struct symfile_segment_data *data;
90
91 phdrs_size = bfd_get_elf_phdr_upper_bound (abfd);
92 if (phdrs_size == -1)
93 return NULL;
94
95 phdrs = alloca (phdrs_size);
96 num_phdrs = bfd_get_elf_phdrs (abfd, phdrs);
97 if (num_phdrs == -1)
98 return NULL;
99
100 num_segments = 0;
101 segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
102 for (i = 0; i < num_phdrs; i++)
103 if (phdrs[i].p_type == PT_LOAD)
104 segments[num_segments++] = &phdrs[i];
105
106 if (num_segments == 0)
107 return NULL;
108
109 data = XZALLOC (struct symfile_segment_data);
110 data->num_segments = num_segments;
111 data->segment_bases = XCALLOC (num_segments, CORE_ADDR);
112 data->segment_sizes = XCALLOC (num_segments, CORE_ADDR);
113
114 for (i = 0; i < num_segments; i++)
115 {
116 data->segment_bases[i] = segments[i]->p_vaddr;
117 data->segment_sizes[i] = segments[i]->p_memsz;
118 }
119
120 num_sections = bfd_count_sections (abfd);
121 data->segment_info = XCALLOC (num_sections, int);
122
123 for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
124 {
125 int j;
126 CORE_ADDR vma;
127
128 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
129 continue;
130
131 vma = bfd_get_section_vma (abfd, sect);
132
133 for (j = 0; j < num_segments; j++)
134 if (segments[j]->p_memsz > 0
135 && vma >= segments[j]->p_vaddr
a366c65a 136 && (vma - segments[j]->p_vaddr) < segments[j]->p_memsz)
31d99776
DJ
137 {
138 data->segment_info[i] = j + 1;
139 break;
140 }
141
ad09a548
DJ
142 /* We should have found a segment for every non-empty section.
143 If we haven't, we will not relocate this section by any
144 offsets we apply to the segments. As an exception, do not
145 warn about SHT_NOBITS sections; in normal ELF execution
146 environments, SHT_NOBITS means zero-initialized and belongs
147 in a segment, but in no-OS environments some tools (e.g. ARM
148 RealView) use SHT_NOBITS for uninitialized data. Since it is
149 uninitialized, it doesn't need a program header. Such
150 binaries are not relocatable. */
151 if (bfd_get_section_size (sect) > 0 && j == num_segments
152 && (bfd_get_section_flags (abfd, sect) & SEC_LOAD) != 0)
28ee876a 153 warning (_("Loadable section \"%s\" outside of ELF segments"),
31d99776
DJ
154 bfd_section_name (abfd, sect));
155 }
156
157 return data;
158}
159
c906108c
SS
160/* We are called once per section from elf_symfile_read. We
161 need to examine each section we are passed, check to see
162 if it is something we are interested in processing, and
163 if so, stash away some access information for the section.
164
165 For now we recognize the dwarf debug information sections and
166 line number sections from matching their section names. The
167 ELF definition is no real help here since it has no direct
168 knowledge of DWARF (by design, so any debugging format can be
169 used).
170
171 We also recognize the ".stab" sections used by the Sun compilers
172 released with Solaris 2.
173
174 FIXME: The section names should not be hardwired strings (what
175 should they be? I don't think most object file formats have enough
0963b4bd 176 section flags to specify what kind of debug section it is.
c906108c
SS
177 -kingdon). */
178
179static void
12b9c64f 180elf_locate_sections (bfd *ignore_abfd, asection *sectp, void *eip)
c906108c 181{
52f0bd74 182 struct elfinfo *ei;
c906108c
SS
183
184 ei = (struct elfinfo *) eip;
7ce59000 185 if (strcmp (sectp->name, ".stab") == 0)
c906108c 186 {
c5aa993b 187 ei->stabsect = sectp;
c906108c 188 }
6314a349 189 else if (strcmp (sectp->name, ".stab.index") == 0)
c906108c 190 {
c5aa993b 191 ei->stabindexsect = sectp;
c906108c 192 }
6314a349 193 else if (strcmp (sectp->name, ".mdebug") == 0)
c906108c 194 {
c5aa993b 195 ei->mdebugsect = sectp;
c906108c
SS
196 }
197}
198
c906108c 199static struct minimal_symbol *
04a679b8
TT
200record_minimal_symbol (const char *name, int name_len, int copy_name,
201 CORE_ADDR address,
f594e5e9
MC
202 enum minimal_symbol_type ms_type,
203 asection *bfd_section, struct objfile *objfile)
c906108c 204{
5e2b427d
UW
205 struct gdbarch *gdbarch = get_objfile_arch (objfile);
206
0875794a
JK
207 if (ms_type == mst_text || ms_type == mst_file_text
208 || ms_type == mst_text_gnu_ifunc)
85ddcc70 209 address = gdbarch_addr_bits_remove (gdbarch, address);
c906108c 210
04a679b8 211 return prim_record_minimal_symbol_full (name, name_len, copy_name, address,
65cf3563
TT
212 ms_type,
213 gdb_bfd_section_index (objfile->obfd,
214 bfd_section),
e6dc44a8 215 objfile);
c906108c
SS
216}
217
7f86f058 218/* Read the symbol table of an ELF file.
c906108c 219
62553543 220 Given an objfile, a symbol table, and a flag indicating whether the
6f610d07
UW
221 symbol table contains regular, dynamic, or synthetic symbols, add all
222 the global function and data symbols to the minimal symbol table.
c906108c 223
c5aa993b
JM
224 In stabs-in-ELF, as implemented by Sun, there are some local symbols
225 defined in the ELF symbol table, which can be used to locate
226 the beginnings of sections from each ".o" file that was linked to
227 form the executable objfile. We gather any such info and record it
7f86f058 228 in data structures hung off the objfile's private data. */
c906108c 229
6f610d07
UW
230#define ST_REGULAR 0
231#define ST_DYNAMIC 1
232#define ST_SYNTHETIC 2
233
c906108c 234static void
6f610d07 235elf_symtab_read (struct objfile *objfile, int type,
04a679b8
TT
236 long number_of_symbols, asymbol **symbol_table,
237 int copy_names)
c906108c 238{
5e2b427d 239 struct gdbarch *gdbarch = get_objfile_arch (objfile);
c906108c 240 asymbol *sym;
c906108c 241 long i;
c906108c 242 CORE_ADDR symaddr;
d4f3574e 243 CORE_ADDR offset;
c906108c
SS
244 enum minimal_symbol_type ms_type;
245 /* If sectinfo is nonNULL, it contains section info that should end up
246 filed in the objfile. */
247 struct stab_section_info *sectinfo = NULL;
248 /* If filesym is nonzero, it points to a file symbol, but we haven't
249 seen any section info for it yet. */
250 asymbol *filesym = 0;
1c9e8358 251 /* Name of filesym. This is either a constant string or is saved on
0af1e9a5
TT
252 the objfile's filename cache. */
253 const char *filesymname = "";
d2f4b8fe 254 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile);
d4f3574e 255 int stripped = (bfd_get_symcount (objfile->obfd) == 0);
c5aa993b 256
0cc7b392 257 for (i = 0; i < number_of_symbols; i++)
c906108c 258 {
0cc7b392
DJ
259 sym = symbol_table[i];
260 if (sym->name == NULL || *sym->name == '\0')
c906108c 261 {
0cc7b392 262 /* Skip names that don't exist (shouldn't happen), or names
0963b4bd 263 that are null strings (may happen). */
0cc7b392
DJ
264 continue;
265 }
c906108c 266
74763737
DJ
267 /* Skip "special" symbols, e.g. ARM mapping symbols. These are
268 symbols which do not correspond to objects in the symbol table,
269 but have some other target-specific meaning. */
270 if (bfd_is_target_special_symbol (objfile->obfd, sym))
60c5725c
DJ
271 {
272 if (gdbarch_record_special_symbol_p (gdbarch))
273 gdbarch_record_special_symbol (gdbarch, objfile, sym);
274 continue;
275 }
74763737 276
65cf3563
TT
277 offset = ANOFFSET (objfile->section_offsets,
278 gdb_bfd_section_index (objfile->obfd, sym->section));
6f610d07 279 if (type == ST_DYNAMIC
45dfa85a 280 && sym->section == bfd_und_section_ptr
0cc7b392
DJ
281 && (sym->flags & BSF_FUNCTION))
282 {
283 struct minimal_symbol *msym;
02c75f72 284 bfd *abfd = objfile->obfd;
dea91a5c 285 asection *sect;
0cc7b392
DJ
286
287 /* Symbol is a reference to a function defined in
288 a shared library.
289 If its value is non zero then it is usually the address
290 of the corresponding entry in the procedure linkage table,
291 plus the desired section offset.
292 If its value is zero then the dynamic linker has to resolve
0963b4bd 293 the symbol. We are unable to find any meaningful address
0cc7b392
DJ
294 for this symbol in the executable file, so we skip it. */
295 symaddr = sym->value;
296 if (symaddr == 0)
297 continue;
02c75f72
UW
298
299 /* sym->section is the undefined section. However, we want to
300 record the section where the PLT stub resides with the
301 minimal symbol. Search the section table for the one that
302 covers the stub's address. */
303 for (sect = abfd->sections; sect != NULL; sect = sect->next)
304 {
305 if ((bfd_get_section_flags (abfd, sect) & SEC_ALLOC) == 0)
306 continue;
307
308 if (symaddr >= bfd_get_section_vma (abfd, sect)
309 && symaddr < bfd_get_section_vma (abfd, sect)
310 + bfd_get_section_size (sect))
311 break;
312 }
313 if (!sect)
314 continue;
315
828cfa8d
JB
316 /* On ia64-hpux, we have discovered that the system linker
317 adds undefined symbols with nonzero addresses that cannot
318 be right (their address points inside the code of another
319 function in the .text section). This creates problems
320 when trying to determine which symbol corresponds to
321 a given address.
322
323 We try to detect those buggy symbols by checking which
324 section we think they correspond to. Normally, PLT symbols
325 are stored inside their own section, and the typical name
326 for that section is ".plt". So, if there is a ".plt"
327 section, and yet the section name of our symbol does not
328 start with ".plt", we ignore that symbol. */
329 if (strncmp (sect->name, ".plt", 4) != 0
330 && bfd_get_section_by_name (abfd, ".plt") != NULL)
331 continue;
332
65cf3563
TT
333 symaddr += ANOFFSET (objfile->section_offsets,
334 gdb_bfd_section_index (objfile->obfd, sect));
02c75f72 335
0cc7b392 336 msym = record_minimal_symbol
04a679b8
TT
337 (sym->name, strlen (sym->name), copy_names,
338 symaddr, mst_solib_trampoline, sect, objfile);
0cc7b392
DJ
339 if (msym != NULL)
340 msym->filename = filesymname;
0cc7b392
DJ
341 continue;
342 }
c906108c 343
0cc7b392
DJ
344 /* If it is a nonstripped executable, do not enter dynamic
345 symbols, as the dynamic symbol table is usually a subset
346 of the main symbol table. */
6f610d07 347 if (type == ST_DYNAMIC && !stripped)
0cc7b392
DJ
348 continue;
349 if (sym->flags & BSF_FILE)
350 {
351 /* STT_FILE debugging symbol that helps stabs-in-elf debugging.
352 Chain any old one onto the objfile; remember new sym. */
353 if (sectinfo != NULL)
c906108c 354 {
0cc7b392
DJ
355 sectinfo->next = dbx->stab_section_info;
356 dbx->stab_section_info = sectinfo;
357 sectinfo = NULL;
358 }
359 filesym = sym;
0af1e9a5 360 filesymname = bcache (filesym->name, strlen (filesym->name) + 1,
706e3705 361 objfile->per_bfd->filename_cache);
0cc7b392
DJ
362 }
363 else if (sym->flags & BSF_SECTION_SYM)
364 continue;
bb869963
SDJ
365 else if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK
366 | BSF_GNU_UNIQUE))
0cc7b392
DJ
367 {
368 struct minimal_symbol *msym;
369
370 /* Select global/local/weak symbols. Note that bfd puts abs
371 symbols in their own section, so all symbols we are
0963b4bd
MS
372 interested in will have a section. */
373 /* Bfd symbols are section relative. */
0cc7b392 374 symaddr = sym->value + sym->section->vma;
45148c2e
UW
375 /* Relocate all non-absolute and non-TLS symbols by the
376 section offset. */
45dfa85a 377 if (sym->section != bfd_abs_section_ptr
45148c2e 378 && !(sym->section->flags & SEC_THREAD_LOCAL))
0cc7b392
DJ
379 {
380 symaddr += offset;
c906108c 381 }
0cc7b392
DJ
382 /* For non-absolute symbols, use the type of the section
383 they are relative to, to intuit text/data. Bfd provides
0963b4bd 384 no way of figuring this out for absolute symbols. */
45dfa85a 385 if (sym->section == bfd_abs_section_ptr)
c906108c 386 {
0cc7b392
DJ
387 /* This is a hack to get the minimal symbol type
388 right for Irix 5, which has absolute addresses
6f610d07
UW
389 with special section indices for dynamic symbols.
390
391 NOTE: uweigand-20071112: Synthetic symbols do not
392 have an ELF-private part, so do not touch those. */
dea91a5c 393 unsigned int shndx = type == ST_SYNTHETIC ? 0 :
0cc7b392
DJ
394 ((elf_symbol_type *) sym)->internal_elf_sym.st_shndx;
395
396 switch (shndx)
c906108c 397 {
0cc7b392
DJ
398 case SHN_MIPS_TEXT:
399 ms_type = mst_text;
400 break;
401 case SHN_MIPS_DATA:
402 ms_type = mst_data;
403 break;
404 case SHN_MIPS_ACOMMON:
405 ms_type = mst_bss;
406 break;
407 default:
408 ms_type = mst_abs;
409 }
410
411 /* If it is an Irix dynamic symbol, skip section name
0963b4bd 412 symbols, relocate all others by section offset. */
0cc7b392
DJ
413 if (ms_type != mst_abs)
414 {
415 if (sym->name[0] == '.')
416 continue;
d4f3574e 417 symaddr += offset;
c906108c 418 }
0cc7b392
DJ
419 }
420 else if (sym->section->flags & SEC_CODE)
421 {
bb869963 422 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
c906108c 423 {
0875794a
JK
424 if (sym->flags & BSF_GNU_INDIRECT_FUNCTION)
425 ms_type = mst_text_gnu_ifunc;
426 else
427 ms_type = mst_text;
0cc7b392 428 }
90359a16
JK
429 /* The BSF_SYNTHETIC check is there to omit ppc64 function
430 descriptors mistaken for static functions starting with 'L'.
431 */
432 else if ((sym->name[0] == '.' && sym->name[1] == 'L'
433 && (sym->flags & BSF_SYNTHETIC) == 0)
0cc7b392
DJ
434 || ((sym->flags & BSF_LOCAL)
435 && sym->name[0] == '$'
436 && sym->name[1] == 'L'))
437 /* Looks like a compiler-generated label. Skip
438 it. The assembler should be skipping these (to
439 keep executables small), but apparently with
440 gcc on the (deleted) delta m88k SVR4, it loses.
441 So to have us check too should be harmless (but
442 I encourage people to fix this in the assembler
443 instead of adding checks here). */
444 continue;
445 else
446 {
447 ms_type = mst_file_text;
c906108c 448 }
0cc7b392
DJ
449 }
450 else if (sym->section->flags & SEC_ALLOC)
451 {
bb869963 452 if (sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE))
c906108c 453 {
0cc7b392 454 if (sym->section->flags & SEC_LOAD)
c906108c 455 {
0cc7b392 456 ms_type = mst_data;
c906108c 457 }
c906108c
SS
458 else
459 {
0cc7b392 460 ms_type = mst_bss;
c906108c
SS
461 }
462 }
0cc7b392 463 else if (sym->flags & BSF_LOCAL)
c906108c 464 {
0cc7b392
DJ
465 /* Named Local variable in a Data section.
466 Check its name for stabs-in-elf. */
467 int special_local_sect;
d7f9d729 468
0cc7b392
DJ
469 if (strcmp ("Bbss.bss", sym->name) == 0)
470 special_local_sect = SECT_OFF_BSS (objfile);
471 else if (strcmp ("Ddata.data", sym->name) == 0)
472 special_local_sect = SECT_OFF_DATA (objfile);
473 else if (strcmp ("Drodata.rodata", sym->name) == 0)
474 special_local_sect = SECT_OFF_RODATA (objfile);
475 else
476 special_local_sect = -1;
477 if (special_local_sect >= 0)
c906108c 478 {
0cc7b392
DJ
479 /* Found a special local symbol. Allocate a
480 sectinfo, if needed, and fill it in. */
481 if (sectinfo == NULL)
c906108c 482 {
0cc7b392
DJ
483 int max_index;
484 size_t size;
485
25c2f6ab
PP
486 max_index = SECT_OFF_BSS (objfile);
487 if (objfile->sect_index_data > max_index)
488 max_index = objfile->sect_index_data;
489 if (objfile->sect_index_rodata > max_index)
490 max_index = objfile->sect_index_rodata;
0cc7b392
DJ
491
492 /* max_index is the largest index we'll
493 use into this array, so we must
494 allocate max_index+1 elements for it.
495 However, 'struct stab_section_info'
496 already includes one element, so we
497 need to allocate max_index aadditional
498 elements. */
dea91a5c 499 size = (sizeof (struct stab_section_info)
c05d19c5 500 + (sizeof (CORE_ADDR) * max_index));
0cc7b392
DJ
501 sectinfo = (struct stab_section_info *)
502 xmalloc (size);
503 memset (sectinfo, 0, size);
504 sectinfo->num_sections = max_index;
505 if (filesym == NULL)
c906108c 506 {
0cc7b392 507 complaint (&symfile_complaints,
3e43a32a
MS
508 _("elf/stab section information %s "
509 "without a preceding file symbol"),
0cc7b392
DJ
510 sym->name);
511 }
512 else
513 {
514 sectinfo->filename =
515 (char *) filesym->name;
c906108c 516 }
c906108c 517 }
0cc7b392
DJ
518 if (sectinfo->sections[special_local_sect] != 0)
519 complaint (&symfile_complaints,
3e43a32a
MS
520 _("duplicated elf/stab section "
521 "information for %s"),
0cc7b392
DJ
522 sectinfo->filename);
523 /* BFD symbols are section relative. */
524 symaddr = sym->value + sym->section->vma;
525 /* Relocate non-absolute symbols by the
526 section offset. */
45dfa85a 527 if (sym->section != bfd_abs_section_ptr)
0cc7b392
DJ
528 symaddr += offset;
529 sectinfo->sections[special_local_sect] = symaddr;
530 /* The special local symbols don't go in the
531 minimal symbol table, so ignore this one. */
532 continue;
533 }
534 /* Not a special stabs-in-elf symbol, do regular
535 symbol processing. */
536 if (sym->section->flags & SEC_LOAD)
537 {
538 ms_type = mst_file_data;
c906108c
SS
539 }
540 else
541 {
0cc7b392 542 ms_type = mst_file_bss;
c906108c
SS
543 }
544 }
545 else
546 {
0cc7b392 547 ms_type = mst_unknown;
c906108c 548 }
0cc7b392
DJ
549 }
550 else
551 {
552 /* FIXME: Solaris2 shared libraries include lots of
dea91a5c 553 odd "absolute" and "undefined" symbols, that play
0cc7b392
DJ
554 hob with actions like finding what function the PC
555 is in. Ignore them if they aren't text, data, or bss. */
556 /* ms_type = mst_unknown; */
0963b4bd 557 continue; /* Skip this symbol. */
0cc7b392
DJ
558 }
559 msym = record_minimal_symbol
04a679b8 560 (sym->name, strlen (sym->name), copy_names, symaddr,
0cc7b392 561 ms_type, sym->section, objfile);
6f610d07 562
0cc7b392
DJ
563 if (msym)
564 {
6f610d07 565 /* NOTE: uweigand-20071112: A synthetic symbol does not have an
24c274a1 566 ELF-private part. */
6f610d07 567 if (type != ST_SYNTHETIC)
24c274a1
AM
568 {
569 /* Pass symbol size field in via BFD. FIXME!!! */
570 elf_symbol_type *elf_sym = (elf_symbol_type *) sym;
571 SET_MSYMBOL_SIZE (msym, elf_sym->internal_elf_sym.st_size);
572 }
dea91a5c 573
a103a963
DJ
574 msym->filename = filesymname;
575 gdbarch_elf_make_msymbol_special (gdbarch, sym, msym);
0cc7b392 576 }
2eaf8d2a 577
715c6909
TT
578 /* If we see a default versioned symbol, install it under
579 its version-less name. */
580 if (msym != NULL)
581 {
582 const char *atsign = strchr (sym->name, '@');
583
584 if (atsign != NULL && atsign[1] == '@' && atsign > sym->name)
585 {
586 int len = atsign - sym->name;
587
588 record_minimal_symbol (sym->name, len, 1, symaddr,
589 ms_type, sym->section, objfile);
590 }
591 }
592
2eaf8d2a
DJ
593 /* For @plt symbols, also record a trampoline to the
594 destination symbol. The @plt symbol will be used in
595 disassembly, and the trampoline will be used when we are
596 trying to find the target. */
597 if (msym && ms_type == mst_text && type == ST_SYNTHETIC)
598 {
599 int len = strlen (sym->name);
600
601 if (len > 4 && strcmp (sym->name + len - 4, "@plt") == 0)
602 {
2eaf8d2a
DJ
603 struct minimal_symbol *mtramp;
604
04a679b8
TT
605 mtramp = record_minimal_symbol (sym->name, len - 4, 1,
606 symaddr,
2eaf8d2a
DJ
607 mst_solib_trampoline,
608 sym->section, objfile);
609 if (mtramp)
610 {
d9eaeb59 611 SET_MSYMBOL_SIZE (mtramp, MSYMBOL_SIZE (msym));
422d65e7 612 mtramp->created_by_gdb = 1;
2eaf8d2a
DJ
613 mtramp->filename = filesymname;
614 gdbarch_elf_make_msymbol_special (gdbarch, sym, mtramp);
615 }
616 }
617 }
c906108c 618 }
c906108c
SS
619 }
620}
621
07be84bf
JK
622/* Build minimal symbols named `function@got.plt' (see SYMBOL_GOT_PLT_SUFFIX)
623 for later look ups of which function to call when user requests
624 a STT_GNU_IFUNC function. As the STT_GNU_IFUNC type is found at the target
625 library defining `function' we cannot yet know while reading OBJFILE which
626 of the SYMBOL_GOT_PLT_SUFFIX entries will be needed and later
627 DYN_SYMBOL_TABLE is no longer easily available for OBJFILE. */
628
629static void
630elf_rel_plt_read (struct objfile *objfile, asymbol **dyn_symbol_table)
631{
632 bfd *obfd = objfile->obfd;
633 const struct elf_backend_data *bed = get_elf_backend_data (obfd);
634 asection *plt, *relplt, *got_plt;
07be84bf
JK
635 int plt_elf_idx;
636 bfd_size_type reloc_count, reloc;
637 char *string_buffer = NULL;
638 size_t string_buffer_size = 0;
639 struct cleanup *back_to;
df6d5441 640 struct gdbarch *gdbarch = get_objfile_arch (objfile);
07be84bf
JK
641 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
642 size_t ptr_size = TYPE_LENGTH (ptr_type);
643
644 if (objfile->separate_debug_objfile_backlink)
645 return;
646
647 plt = bfd_get_section_by_name (obfd, ".plt");
648 if (plt == NULL)
649 return;
650 plt_elf_idx = elf_section_data (plt)->this_idx;
651
652 got_plt = bfd_get_section_by_name (obfd, ".got.plt");
653 if (got_plt == NULL)
654 return;
655
656 /* This search algorithm is from _bfd_elf_canonicalize_dynamic_reloc. */
657 for (relplt = obfd->sections; relplt != NULL; relplt = relplt->next)
658 if (elf_section_data (relplt)->this_hdr.sh_info == plt_elf_idx
659 && (elf_section_data (relplt)->this_hdr.sh_type == SHT_REL
660 || elf_section_data (relplt)->this_hdr.sh_type == SHT_RELA))
661 break;
662 if (relplt == NULL)
663 return;
664
665 if (! bed->s->slurp_reloc_table (obfd, relplt, dyn_symbol_table, TRUE))
666 return;
667
668 back_to = make_cleanup (free_current_contents, &string_buffer);
669
670 reloc_count = relplt->size / elf_section_data (relplt)->this_hdr.sh_entsize;
671 for (reloc = 0; reloc < reloc_count; reloc++)
672 {
22e048c9 673 const char *name;
07be84bf
JK
674 struct minimal_symbol *msym;
675 CORE_ADDR address;
676 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
677 size_t name_len;
678
679 name = bfd_asymbol_name (*relplt->relocation[reloc].sym_ptr_ptr);
680 name_len = strlen (name);
681 address = relplt->relocation[reloc].address;
682
683 /* Does the pointer reside in the .got.plt section? */
684 if (!(bfd_get_section_vma (obfd, got_plt) <= address
685 && address < bfd_get_section_vma (obfd, got_plt)
686 + bfd_get_section_size (got_plt)))
687 continue;
688
689 /* We cannot check if NAME is a reference to mst_text_gnu_ifunc as in
690 OBJFILE the symbol is undefined and the objfile having NAME defined
691 may not yet have been loaded. */
692
3807f613 693 if (string_buffer_size < name_len + got_suffix_len + 1)
07be84bf
JK
694 {
695 string_buffer_size = 2 * (name_len + got_suffix_len);
696 string_buffer = xrealloc (string_buffer, string_buffer_size);
697 }
698 memcpy (string_buffer, name, name_len);
699 memcpy (&string_buffer[name_len], SYMBOL_GOT_PLT_SUFFIX,
3807f613 700 got_suffix_len + 1);
07be84bf
JK
701
702 msym = record_minimal_symbol (string_buffer, name_len + got_suffix_len,
703 1, address, mst_slot_got_plt, got_plt,
704 objfile);
705 if (msym)
d9eaeb59 706 SET_MSYMBOL_SIZE (msym, ptr_size);
07be84bf
JK
707 }
708
709 do_cleanups (back_to);
710}
711
712/* The data pointer is htab_t for gnu_ifunc_record_cache_unchecked. */
713
714static const struct objfile_data *elf_objfile_gnu_ifunc_cache_data;
715
716/* Map function names to CORE_ADDR in elf_objfile_gnu_ifunc_cache_data. */
717
718struct elf_gnu_ifunc_cache
719{
720 /* This is always a function entry address, not a function descriptor. */
721 CORE_ADDR addr;
722
723 char name[1];
724};
725
726/* htab_hash for elf_objfile_gnu_ifunc_cache_data. */
727
728static hashval_t
729elf_gnu_ifunc_cache_hash (const void *a_voidp)
730{
731 const struct elf_gnu_ifunc_cache *a = a_voidp;
732
733 return htab_hash_string (a->name);
734}
735
736/* htab_eq for elf_objfile_gnu_ifunc_cache_data. */
737
738static int
739elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
740{
741 const struct elf_gnu_ifunc_cache *a = a_voidp;
742 const struct elf_gnu_ifunc_cache *b = b_voidp;
743
744 return strcmp (a->name, b->name) == 0;
745}
746
747/* Record the target function address of a STT_GNU_IFUNC function NAME is the
748 function entry address ADDR. Return 1 if NAME and ADDR are considered as
749 valid and therefore they were successfully recorded, return 0 otherwise.
750
751 Function does not expect a duplicate entry. Use
752 elf_gnu_ifunc_resolve_by_cache first to check if the entry for NAME already
753 exists. */
754
755static int
756elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
757{
7cbd4a93 758 struct bound_minimal_symbol msym;
07be84bf
JK
759 asection *sect;
760 struct objfile *objfile;
761 htab_t htab;
762 struct elf_gnu_ifunc_cache entry_local, *entry_p;
763 void **slot;
764
765 msym = lookup_minimal_symbol_by_pc (addr);
7cbd4a93 766 if (msym.minsym == NULL)
07be84bf 767 return 0;
7cbd4a93 768 if (SYMBOL_VALUE_ADDRESS (msym.minsym) != addr)
07be84bf
JK
769 return 0;
770 /* minimal symbols have always SYMBOL_OBJ_SECTION non-NULL. */
e27d198c
TT
771 sect = SYMBOL_OBJ_SECTION (msym.objfile, msym.minsym)->the_bfd_section;
772 objfile = msym.objfile;
07be84bf
JK
773
774 /* If .plt jumps back to .plt the symbol is still deferred for later
775 resolution and it has no use for GDB. Besides ".text" this symbol can
776 reside also in ".opd" for ppc64 function descriptor. */
777 if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0)
778 return 0;
779
780 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
781 if (htab == NULL)
782 {
783 htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash,
784 elf_gnu_ifunc_cache_eq,
785 NULL, &objfile->objfile_obstack,
786 hashtab_obstack_allocate,
787 dummy_obstack_deallocate);
788 set_objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data, htab);
789 }
790
791 entry_local.addr = addr;
792 obstack_grow (&objfile->objfile_obstack, &entry_local,
793 offsetof (struct elf_gnu_ifunc_cache, name));
794 obstack_grow_str0 (&objfile->objfile_obstack, name);
795 entry_p = obstack_finish (&objfile->objfile_obstack);
796
797 slot = htab_find_slot (htab, entry_p, INSERT);
798 if (*slot != NULL)
799 {
800 struct elf_gnu_ifunc_cache *entry_found_p = *slot;
df6d5441 801 struct gdbarch *gdbarch = get_objfile_arch (objfile);
07be84bf
JK
802
803 if (entry_found_p->addr != addr)
804 {
805 /* This case indicates buggy inferior program, the resolved address
806 should never change. */
807
808 warning (_("gnu-indirect-function \"%s\" has changed its resolved "
809 "function_address from %s to %s"),
810 name, paddress (gdbarch, entry_found_p->addr),
811 paddress (gdbarch, addr));
812 }
813
814 /* New ENTRY_P is here leaked/duplicate in the OBJFILE obstack. */
815 }
816 *slot = entry_p;
817
818 return 1;
819}
820
821/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
822 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
823 is not NULL) and the function returns 1. It returns 0 otherwise.
824
825 Only the elf_objfile_gnu_ifunc_cache_data hash table is searched by this
826 function. */
827
828static int
829elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
830{
831 struct objfile *objfile;
832
833 ALL_PSPACE_OBJFILES (current_program_space, objfile)
834 {
835 htab_t htab;
836 struct elf_gnu_ifunc_cache *entry_p;
837 void **slot;
838
839 htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
840 if (htab == NULL)
841 continue;
842
843 entry_p = alloca (sizeof (*entry_p) + strlen (name));
844 strcpy (entry_p->name, name);
845
846 slot = htab_find_slot (htab, entry_p, NO_INSERT);
847 if (slot == NULL)
848 continue;
849 entry_p = *slot;
850 gdb_assert (entry_p != NULL);
851
852 if (addr_p)
853 *addr_p = entry_p->addr;
854 return 1;
855 }
856
857 return 0;
858}
859
860/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
861 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
862 is not NULL) and the function returns 1. It returns 0 otherwise.
863
864 Only the SYMBOL_GOT_PLT_SUFFIX locations are searched by this function.
865 elf_gnu_ifunc_resolve_by_cache must have been already called for NAME to
866 prevent cache entries duplicates. */
867
868static int
869elf_gnu_ifunc_resolve_by_got (const char *name, CORE_ADDR *addr_p)
870{
871 char *name_got_plt;
872 struct objfile *objfile;
873 const size_t got_suffix_len = strlen (SYMBOL_GOT_PLT_SUFFIX);
874
875 name_got_plt = alloca (strlen (name) + got_suffix_len + 1);
876 sprintf (name_got_plt, "%s" SYMBOL_GOT_PLT_SUFFIX, name);
877
878 ALL_PSPACE_OBJFILES (current_program_space, objfile)
879 {
880 bfd *obfd = objfile->obfd;
df6d5441 881 struct gdbarch *gdbarch = get_objfile_arch (objfile);
07be84bf
JK
882 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
883 size_t ptr_size = TYPE_LENGTH (ptr_type);
884 CORE_ADDR pointer_address, addr;
885 asection *plt;
886 gdb_byte *buf = alloca (ptr_size);
887 struct minimal_symbol *msym;
888
889 msym = lookup_minimal_symbol (name_got_plt, NULL, objfile);
890 if (msym == NULL)
891 continue;
892 if (MSYMBOL_TYPE (msym) != mst_slot_got_plt)
893 continue;
894 pointer_address = SYMBOL_VALUE_ADDRESS (msym);
895
896 plt = bfd_get_section_by_name (obfd, ".plt");
897 if (plt == NULL)
898 continue;
899
900 if (MSYMBOL_SIZE (msym) != ptr_size)
901 continue;
902 if (target_read_memory (pointer_address, buf, ptr_size) != 0)
903 continue;
904 addr = extract_typed_address (buf, ptr_type);
905 addr = gdbarch_convert_from_func_ptr_addr (gdbarch, addr,
906 &current_target);
907
908 if (addr_p)
909 *addr_p = addr;
910 if (elf_gnu_ifunc_record_cache (name, addr))
911 return 1;
912 }
913
914 return 0;
915}
916
917/* Try to find the target resolved function entry address of a STT_GNU_IFUNC
918 function NAME. If the address is found it is stored to *ADDR_P (if ADDR_P
919 is not NULL) and the function returns 1. It returns 0 otherwise.
920
921 Both the elf_objfile_gnu_ifunc_cache_data hash table and
922 SYMBOL_GOT_PLT_SUFFIX locations are searched by this function. */
923
924static int
925elf_gnu_ifunc_resolve_name (const char *name, CORE_ADDR *addr_p)
926{
927 if (elf_gnu_ifunc_resolve_by_cache (name, addr_p))
928 return 1;
dea91a5c 929
07be84bf
JK
930 if (elf_gnu_ifunc_resolve_by_got (name, addr_p))
931 return 1;
932
933 return 0;
934}
935
936/* Call STT_GNU_IFUNC - a function returning addresss of a real function to
937 call. PC is theSTT_GNU_IFUNC resolving function entry. The value returned
938 is the entry point of the resolved STT_GNU_IFUNC target function to call.
939 */
940
941static CORE_ADDR
942elf_gnu_ifunc_resolve_addr (struct gdbarch *gdbarch, CORE_ADDR pc)
943{
2c02bd72 944 const char *name_at_pc;
07be84bf
JK
945 CORE_ADDR start_at_pc, address;
946 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
947 struct value *function, *address_val;
948
949 /* Try first any non-intrusive methods without an inferior call. */
950
951 if (find_pc_partial_function (pc, &name_at_pc, &start_at_pc, NULL)
952 && start_at_pc == pc)
953 {
954 if (elf_gnu_ifunc_resolve_name (name_at_pc, &address))
955 return address;
956 }
957 else
958 name_at_pc = NULL;
959
960 function = allocate_value (func_func_type);
961 set_value_address (function, pc);
962
963 /* STT_GNU_IFUNC resolver functions have no parameters. FUNCTION is the
964 function entry address. ADDRESS may be a function descriptor. */
965
966 address_val = call_function_by_hand (function, 0, NULL);
967 address = value_as_address (address_val);
968 address = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
969 &current_target);
970
971 if (name_at_pc)
972 elf_gnu_ifunc_record_cache (name_at_pc, address);
973
974 return address;
975}
976
0e30163f
JK
977/* Handle inferior hit of bp_gnu_ifunc_resolver, see its definition. */
978
979static void
980elf_gnu_ifunc_resolver_stop (struct breakpoint *b)
981{
982 struct breakpoint *b_return;
983 struct frame_info *prev_frame = get_prev_frame (get_current_frame ());
984 struct frame_id prev_frame_id = get_stack_frame_id (prev_frame);
985 CORE_ADDR prev_pc = get_frame_pc (prev_frame);
986 int thread_id = pid_to_thread_id (inferior_ptid);
987
988 gdb_assert (b->type == bp_gnu_ifunc_resolver);
989
990 for (b_return = b->related_breakpoint; b_return != b;
991 b_return = b_return->related_breakpoint)
992 {
993 gdb_assert (b_return->type == bp_gnu_ifunc_resolver_return);
994 gdb_assert (b_return->loc != NULL && b_return->loc->next == NULL);
995 gdb_assert (frame_id_p (b_return->frame_id));
996
997 if (b_return->thread == thread_id
998 && b_return->loc->requested_address == prev_pc
999 && frame_id_eq (b_return->frame_id, prev_frame_id))
1000 break;
1001 }
1002
1003 if (b_return == b)
1004 {
1005 struct symtab_and_line sal;
1006
1007 /* No need to call find_pc_line for symbols resolving as this is only
1008 a helper breakpointer never shown to the user. */
1009
1010 init_sal (&sal);
1011 sal.pspace = current_inferior ()->pspace;
1012 sal.pc = prev_pc;
1013 sal.section = find_pc_overlay (sal.pc);
1014 sal.explicit_pc = 1;
1015 b_return = set_momentary_breakpoint (get_frame_arch (prev_frame), sal,
1016 prev_frame_id,
1017 bp_gnu_ifunc_resolver_return);
1018
c70a6932
JK
1019 /* set_momentary_breakpoint invalidates PREV_FRAME. */
1020 prev_frame = NULL;
1021
0e30163f
JK
1022 /* Add new b_return to the ring list b->related_breakpoint. */
1023 gdb_assert (b_return->related_breakpoint == b_return);
1024 b_return->related_breakpoint = b->related_breakpoint;
1025 b->related_breakpoint = b_return;
1026 }
1027}
1028
1029/* Handle inferior hit of bp_gnu_ifunc_resolver_return, see its definition. */
1030
1031static void
1032elf_gnu_ifunc_resolver_return_stop (struct breakpoint *b)
1033{
1034 struct gdbarch *gdbarch = get_frame_arch (get_current_frame ());
1035 struct type *func_func_type = builtin_type (gdbarch)->builtin_func_func;
1036 struct type *value_type = TYPE_TARGET_TYPE (func_func_type);
1037 struct regcache *regcache = get_thread_regcache (inferior_ptid);
6a3a010b 1038 struct value *func_func;
0e30163f
JK
1039 struct value *value;
1040 CORE_ADDR resolved_address, resolved_pc;
1041 struct symtab_and_line sal;
f1310107 1042 struct symtabs_and_lines sals, sals_end;
0e30163f
JK
1043
1044 gdb_assert (b->type == bp_gnu_ifunc_resolver_return);
1045
0e30163f
JK
1046 while (b->related_breakpoint != b)
1047 {
1048 struct breakpoint *b_next = b->related_breakpoint;
1049
1050 switch (b->type)
1051 {
1052 case bp_gnu_ifunc_resolver:
1053 break;
1054 case bp_gnu_ifunc_resolver_return:
1055 delete_breakpoint (b);
1056 break;
1057 default:
1058 internal_error (__FILE__, __LINE__,
1059 _("handle_inferior_event: Invalid "
1060 "gnu-indirect-function breakpoint type %d"),
1061 (int) b->type);
1062 }
1063 b = b_next;
1064 }
1065 gdb_assert (b->type == bp_gnu_ifunc_resolver);
6a3a010b
MR
1066 gdb_assert (b->loc->next == NULL);
1067
1068 func_func = allocate_value (func_func_type);
1069 set_value_address (func_func, b->loc->related_address);
1070
1071 value = allocate_value (value_type);
1072 gdbarch_return_value (gdbarch, func_func, value_type, regcache,
1073 value_contents_raw (value), NULL);
1074 resolved_address = value_as_address (value);
1075 resolved_pc = gdbarch_convert_from_func_ptr_addr (gdbarch,
1076 resolved_address,
1077 &current_target);
0e30163f 1078
f8eba3c6 1079 gdb_assert (current_program_space == b->pspace || b->pspace == NULL);
0e30163f
JK
1080 elf_gnu_ifunc_record_cache (b->addr_string, resolved_pc);
1081
1082 sal = find_pc_line (resolved_pc, 0);
1083 sals.nelts = 1;
1084 sals.sals = &sal;
f1310107 1085 sals_end.nelts = 0;
0e30163f
JK
1086
1087 b->type = bp_breakpoint;
f1310107 1088 update_breakpoint_locations (b, sals, sals_end);
0e30163f
JK
1089}
1090
c906108c 1091/* Scan and build partial symbols for a symbol file.
dea91a5c 1092 We have been initialized by a call to elf_symfile_init, which
c906108c
SS
1093 currently does nothing.
1094
1095 SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
1096 in each section. We simplify it down to a single offset for all
1097 symbols. FIXME.
1098
c906108c
SS
1099 This function only does the minimum work necessary for letting the
1100 user "name" things symbolically; it does not read the entire symtab.
1101 Instead, it reads the external and static symbols and puts them in partial
1102 symbol tables. When more extensive information is requested of a
1103 file, the corresponding partial symbol table is mutated into a full
1104 fledged symbol table by going back and reading the symbols
1105 for real.
1106
1107 We look for sections with specific names, to tell us what debug
1108 format to look for: FIXME!!!
1109
c906108c
SS
1110 elfstab_build_psymtabs() handles STABS symbols;
1111 mdebug_build_psymtabs() handles ECOFF debugging information.
1112
1113 Note that ELF files have a "minimal" symbol table, which looks a lot
1114 like a COFF symbol table, but has only the minimal information necessary
1115 for linking. We process this also, and use the information to
1116 build gdb's minimal symbol table. This gives us some minimal debugging
1117 capability even for files compiled without -g. */
1118
1119static void
f4352531 1120elf_symfile_read (struct objfile *objfile, int symfile_flags)
c906108c 1121{
63524580 1122 bfd *synth_abfd, *abfd = objfile->obfd;
c906108c
SS
1123 struct elfinfo ei;
1124 struct cleanup *back_to;
62553543
EZ
1125 long symcount = 0, dynsymcount = 0, synthcount, storage_needed;
1126 asymbol **symbol_table = NULL, **dyn_symbol_table = NULL;
1127 asymbol *synthsyms;
d2f4b8fe 1128 struct dbx_symfile_info *dbx;
c906108c 1129
45cfd468
DE
1130 if (symtab_create_debug)
1131 {
1132 fprintf_unfiltered (gdb_stdlog,
1133 "Reading minimal symbols of objfile %s ...\n",
4262abfb 1134 objfile_name (objfile));
45cfd468
DE
1135 }
1136
c906108c 1137 init_minimal_symbol_collection ();
56e290f4 1138 back_to = make_cleanup_discard_minimal_symbols ();
c906108c
SS
1139
1140 memset ((char *) &ei, 0, sizeof (ei));
1141
0963b4bd 1142 /* Allocate struct to keep track of the symfile. */
d2f4b8fe
TT
1143 dbx = XCNEW (struct dbx_symfile_info);
1144 set_objfile_data (objfile, dbx_objfile_data_key, dbx);
12b9c64f 1145 make_cleanup (free_elfinfo, (void *) objfile);
c906108c 1146
3e43a32a 1147 /* Process the normal ELF symbol table first. This may write some
d2f4b8fe
TT
1148 chain of info into the dbx_symfile_info of the objfile, which can
1149 later be used by elfstab_offset_sections. */
c906108c 1150
62553543
EZ
1151 storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
1152 if (storage_needed < 0)
3e43a32a
MS
1153 error (_("Can't read symbols from %s: %s"),
1154 bfd_get_filename (objfile->obfd),
62553543
EZ
1155 bfd_errmsg (bfd_get_error ()));
1156
1157 if (storage_needed > 0)
1158 {
1159 symbol_table = (asymbol **) xmalloc (storage_needed);
1160 make_cleanup (xfree, symbol_table);
1161 symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
1162
1163 if (symcount < 0)
3e43a32a
MS
1164 error (_("Can't read symbols from %s: %s"),
1165 bfd_get_filename (objfile->obfd),
62553543
EZ
1166 bfd_errmsg (bfd_get_error ()));
1167
04a679b8 1168 elf_symtab_read (objfile, ST_REGULAR, symcount, symbol_table, 0);
62553543 1169 }
c906108c
SS
1170
1171 /* Add the dynamic symbols. */
1172
62553543
EZ
1173 storage_needed = bfd_get_dynamic_symtab_upper_bound (objfile->obfd);
1174
1175 if (storage_needed > 0)
1176 {
3f1eff0a
JK
1177 /* Memory gets permanently referenced from ABFD after
1178 bfd_get_synthetic_symtab so it must not get freed before ABFD gets.
1179 It happens only in the case when elf_slurp_reloc_table sees
1180 asection->relocation NULL. Determining which section is asection is
1181 done by _bfd_elf_get_synthetic_symtab which is all a bfd
1182 implementation detail, though. */
1183
1184 dyn_symbol_table = bfd_alloc (abfd, storage_needed);
62553543
EZ
1185 dynsymcount = bfd_canonicalize_dynamic_symtab (objfile->obfd,
1186 dyn_symbol_table);
1187
1188 if (dynsymcount < 0)
3e43a32a
MS
1189 error (_("Can't read symbols from %s: %s"),
1190 bfd_get_filename (objfile->obfd),
62553543
EZ
1191 bfd_errmsg (bfd_get_error ()));
1192
04a679b8 1193 elf_symtab_read (objfile, ST_DYNAMIC, dynsymcount, dyn_symbol_table, 0);
07be84bf
JK
1194
1195 elf_rel_plt_read (objfile, dyn_symbol_table);
62553543
EZ
1196 }
1197
63524580
JK
1198 /* Contrary to binutils --strip-debug/--only-keep-debug the strip command from
1199 elfutils (eu-strip) moves even the .symtab section into the .debug file.
1200
1201 bfd_get_synthetic_symtab on ppc64 for each function descriptor ELF symbol
1202 'name' creates a new BSF_SYNTHETIC ELF symbol '.name' with its code
1203 address. But with eu-strip files bfd_get_synthetic_symtab would fail to
1204 read the code address from .opd while it reads the .symtab section from
1205 a separate debug info file as the .opd section is SHT_NOBITS there.
1206
1207 With SYNTH_ABFD the .opd section will be read from the original
1208 backlinked binary where it is valid. */
1209
1210 if (objfile->separate_debug_objfile_backlink)
1211 synth_abfd = objfile->separate_debug_objfile_backlink->obfd;
1212 else
1213 synth_abfd = abfd;
1214
62553543
EZ
1215 /* Add synthetic symbols - for instance, names for any PLT entries. */
1216
63524580 1217 synthcount = bfd_get_synthetic_symtab (synth_abfd, symcount, symbol_table,
62553543
EZ
1218 dynsymcount, dyn_symbol_table,
1219 &synthsyms);
1220 if (synthcount > 0)
1221 {
1222 asymbol **synth_symbol_table;
1223 long i;
1224
1225 make_cleanup (xfree, synthsyms);
1226 synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
1227 for (i = 0; i < synthcount; i++)
9f20e3da 1228 synth_symbol_table[i] = synthsyms + i;
62553543 1229 make_cleanup (xfree, synth_symbol_table);
3e43a32a
MS
1230 elf_symtab_read (objfile, ST_SYNTHETIC, synthcount,
1231 synth_symbol_table, 1);
62553543 1232 }
c906108c 1233
7134143f
DJ
1234 /* Install any minimal symbols that have been collected as the current
1235 minimal symbols for this objfile. The debug readers below this point
1236 should not generate new minimal symbols; if they do it's their
1237 responsibility to install them. "mdebug" appears to be the only one
1238 which will do this. */
1239
1240 install_minimal_symbols (objfile);
1241 do_cleanups (back_to);
1242
4f00dda3
DE
1243 if (symtab_create_debug)
1244 fprintf_unfiltered (gdb_stdlog, "Done reading minimal symbols.\n");
1245
c906108c 1246 /* Now process debugging information, which is contained in
0963b4bd 1247 special ELF sections. */
c906108c 1248
0963b4bd 1249 /* We first have to find them... */
12b9c64f 1250 bfd_map_over_sections (abfd, elf_locate_sections, (void *) & ei);
c906108c
SS
1251
1252 /* ELF debugging information is inserted into the psymtab in the
1253 order of least informative first - most informative last. Since
1254 the psymtab table is searched `most recent insertion first' this
1255 increases the probability that more detailed debug information
1256 for a section is found.
1257
1258 For instance, an object file might contain both .mdebug (XCOFF)
1259 and .debug_info (DWARF2) sections then .mdebug is inserted first
1260 (searched last) and DWARF2 is inserted last (searched first). If
1261 we don't do this then the XCOFF info is found first - for code in
0963b4bd 1262 an included file XCOFF info is useless. */
c906108c
SS
1263
1264 if (ei.mdebugsect)
1265 {
1266 const struct ecoff_debug_swap *swap;
1267
1268 /* .mdebug section, presumably holding ECOFF debugging
c5aa993b 1269 information. */
c906108c
SS
1270 swap = get_elf_backend_data (abfd)->elf_backend_ecoff_debug_swap;
1271 if (swap)
d4f3574e 1272 elfmdebug_build_psymtabs (objfile, swap, ei.mdebugsect);
c906108c
SS
1273 }
1274 if (ei.stabsect)
1275 {
1276 asection *str_sect;
1277
1278 /* Stab sections have an associated string table that looks like
c5aa993b 1279 a separate section. */
c906108c
SS
1280 str_sect = bfd_get_section_by_name (abfd, ".stabstr");
1281
1282 /* FIXME should probably warn about a stab section without a stabstr. */
1283 if (str_sect)
1284 elfstab_build_psymtabs (objfile,
086df311 1285 ei.stabsect,
c906108c
SS
1286 str_sect->filepos,
1287 bfd_section_size (abfd, str_sect));
1288 }
9291a0cd 1289
251d32d9 1290 if (dwarf2_has_info (objfile, NULL))
b11896a5 1291 {
3e03848b
JK
1292 /* elf_sym_fns_gdb_index cannot handle simultaneous non-DWARF debug
1293 information present in OBJFILE. If there is such debug info present
1294 never use .gdb_index. */
1295
1296 if (!objfile_has_partial_symbols (objfile)
1297 && dwarf2_initialize_objfile (objfile))
8fb8eb5c 1298 objfile_set_sym_fns (objfile, &elf_sym_fns_gdb_index);
b11896a5
TT
1299 else
1300 {
1301 /* It is ok to do this even if the stabs reader made some
1302 partial symbols, because OBJF_PSYMTABS_READ has not been
1303 set, and so our lazy reader function will still be called
1304 when needed. */
8fb8eb5c 1305 objfile_set_sym_fns (objfile, &elf_sym_fns_lazy_psyms);
b11896a5
TT
1306 }
1307 }
3e43a32a
MS
1308 /* If the file has its own symbol tables it has no separate debug
1309 info. `.dynsym'/`.symtab' go to MSYMBOLS, `.debug_info' goes to
1310 SYMTABS/PSYMTABS. `.gnu_debuglink' may no longer be present with
8a92335b
JK
1311 `.note.gnu.build-id'.
1312
1313 .gnu_debugdata is !objfile_has_partial_symbols because it contains only
1314 .symtab, not .debug_* section. But if we already added .gnu_debugdata as
1315 an objfile via find_separate_debug_file_in_section there was no separate
1316 debug info available. Therefore do not attempt to search for another one,
1317 objfile->separate_debug_objfile->separate_debug_objfile GDB guarantees to
1318 be NULL and we would possibly violate it. */
1319
1320 else if (!objfile_has_partial_symbols (objfile)
1321 && objfile->separate_debug_objfile == NULL
1322 && objfile->separate_debug_objfile_backlink == NULL)
9cce227f
TG
1323 {
1324 char *debugfile;
1325
1326 debugfile = find_separate_debug_file_by_buildid (objfile);
1327
1328 if (debugfile == NULL)
1329 debugfile = find_separate_debug_file_by_debuglink (objfile);
1330
1331 if (debugfile)
1332 {
8ac244b4 1333 struct cleanup *cleanup = make_cleanup (xfree, debugfile);
9cce227f 1334 bfd *abfd = symfile_bfd_open (debugfile);
d7f9d729 1335
8ac244b4 1336 make_cleanup_bfd_unref (abfd);
24ba069a 1337 symbol_file_add_separate (abfd, debugfile, symfile_flags, objfile);
8ac244b4 1338 do_cleanups (cleanup);
9cce227f
TG
1339 }
1340 }
c906108c
SS
1341}
1342
b11896a5
TT
1343/* Callback to lazily read psymtabs. */
1344
1345static void
1346read_psyms (struct objfile *objfile)
1347{
251d32d9 1348 if (dwarf2_has_info (objfile, NULL))
b11896a5
TT
1349 dwarf2_build_psymtabs (objfile);
1350}
1351
d2f4b8fe
TT
1352/* This cleans up the objfile's dbx symfile info, and the chain of
1353 stab_section_info's, that might be dangling from it. */
c906108c
SS
1354
1355static void
12b9c64f 1356free_elfinfo (void *objp)
c906108c 1357{
c5aa993b 1358 struct objfile *objfile = (struct objfile *) objp;
d2f4b8fe 1359 struct dbx_symfile_info *dbxinfo = DBX_SYMFILE_INFO (objfile);
c906108c
SS
1360 struct stab_section_info *ssi, *nssi;
1361
1362 ssi = dbxinfo->stab_section_info;
1363 while (ssi)
1364 {
1365 nssi = ssi->next;
2dc74dc1 1366 xfree (ssi);
c906108c
SS
1367 ssi = nssi;
1368 }
1369
1370 dbxinfo->stab_section_info = 0; /* Just say No mo info about this. */
1371}
1372
1373
1374/* Initialize anything that needs initializing when a completely new symbol
1375 file is specified (not just adding some symbols from another file, e.g. a
1376 shared library).
1377
3e43a32a
MS
1378 We reinitialize buildsym, since we may be reading stabs from an ELF
1379 file. */
c906108c
SS
1380
1381static void
fba45db2 1382elf_new_init (struct objfile *ignore)
c906108c
SS
1383{
1384 stabsread_new_init ();
1385 buildsym_new_init ();
1386}
1387
1388/* Perform any local cleanups required when we are done with a particular
1389 objfile. I.E, we are in the process of discarding all symbol information
1390 for an objfile, freeing up all memory held for it, and unlinking the
0963b4bd 1391 objfile struct from the global list of known objfiles. */
c906108c
SS
1392
1393static void
fba45db2 1394elf_symfile_finish (struct objfile *objfile)
c906108c 1395{
fe3e1990 1396 dwarf2_free_objfile (objfile);
c906108c
SS
1397}
1398
1399/* ELF specific initialization routine for reading symbols.
1400
1401 It is passed a pointer to a struct sym_fns which contains, among other
1402 things, the BFD for the file whose symbols are being read, and a slot for
1403 a pointer to "private data" which we can fill with goodies.
1404
1405 For now at least, we have nothing in particular to do, so this function is
0963b4bd 1406 just a stub. */
c906108c
SS
1407
1408static void
fba45db2 1409elf_symfile_init (struct objfile *objfile)
c906108c
SS
1410{
1411 /* ELF objects may be reordered, so set OBJF_REORDERED. If we
1412 find this causes a significant slowdown in gdb then we could
1413 set it in the debug symbol readers only when necessary. */
1414 objfile->flags |= OBJF_REORDERED;
1415}
1416
1417/* When handling an ELF file that contains Sun STABS debug info,
1418 some of the debug info is relative to the particular chunk of the
1419 section that was generated in its individual .o file. E.g.
1420 offsets to static variables are relative to the start of the data
1421 segment *for that module before linking*. This information is
1422 painfully squirreled away in the ELF symbol table as local symbols
1423 with wierd names. Go get 'em when needed. */
1424
1425void
fba45db2 1426elfstab_offset_sections (struct objfile *objfile, struct partial_symtab *pst)
c906108c 1427{
72b9f47f 1428 const char *filename = pst->filename;
d2f4b8fe 1429 struct dbx_symfile_info *dbx = DBX_SYMFILE_INFO (objfile);
c906108c
SS
1430 struct stab_section_info *maybe = dbx->stab_section_info;
1431 struct stab_section_info *questionable = 0;
1432 int i;
c906108c
SS
1433
1434 /* The ELF symbol info doesn't include path names, so strip the path
1435 (if any) from the psymtab filename. */
0ba1096a 1436 filename = lbasename (filename);
c906108c
SS
1437
1438 /* FIXME: This linear search could speed up significantly
1439 if it was chained in the right order to match how we search it,
0963b4bd 1440 and if we unchained when we found a match. */
c906108c
SS
1441 for (; maybe; maybe = maybe->next)
1442 {
1443 if (filename[0] == maybe->filename[0]
0ba1096a 1444 && filename_cmp (filename, maybe->filename) == 0)
c906108c
SS
1445 {
1446 /* We found a match. But there might be several source files
1447 (from different directories) with the same name. */
1448 if (0 == maybe->found)
1449 break;
c5aa993b 1450 questionable = maybe; /* Might use it later. */
c906108c
SS
1451 }
1452 }
1453
1454 if (maybe == 0 && questionable != 0)
1455 {
23136709 1456 complaint (&symfile_complaints,
3e43a32a
MS
1457 _("elf/stab section information questionable for %s"),
1458 filename);
c906108c
SS
1459 maybe = questionable;
1460 }
1461
1462 if (maybe)
1463 {
1464 /* Found it! Allocate a new psymtab struct, and fill it in. */
1465 maybe->found++;
1466 pst->section_offsets = (struct section_offsets *)
dea91a5c 1467 obstack_alloc (&objfile->objfile_obstack,
a39a16c4
MM
1468 SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
1469 for (i = 0; i < maybe->num_sections; i++)
a4c8257b 1470 (pst->section_offsets)->offsets[i] = maybe->sections[i];
c906108c
SS
1471 return;
1472 }
1473
1474 /* We were unable to find any offsets for this file. Complain. */
c5aa993b 1475 if (dbx->stab_section_info) /* If there *is* any info, */
23136709 1476 complaint (&symfile_complaints,
e2e0b3e5 1477 _("elf/stab section information missing for %s"), filename);
c906108c 1478}
55aa24fb
SDJ
1479
1480/* Implementation of `sym_get_probes', as documented in symfile.h. */
1481
1482static VEC (probe_p) *
1483elf_get_probes (struct objfile *objfile)
1484{
1485 VEC (probe_p) *probes_per_objfile;
1486
1487 /* Have we parsed this objfile's probes already? */
1488 probes_per_objfile = objfile_data (objfile, probe_key);
1489
1490 if (!probes_per_objfile)
1491 {
1492 int ix;
1493 const struct probe_ops *probe_ops;
1494
1495 /* Here we try to gather information about all types of probes from the
1496 objfile. */
1497 for (ix = 0; VEC_iterate (probe_ops_cp, all_probe_ops, ix, probe_ops);
1498 ix++)
1499 probe_ops->get_probes (&probes_per_objfile, objfile);
1500
1501 if (probes_per_objfile == NULL)
1502 {
1503 VEC_reserve (probe_p, probes_per_objfile, 1);
1504 gdb_assert (probes_per_objfile != NULL);
1505 }
1506
1507 set_objfile_data (objfile, probe_key, probes_per_objfile);
1508 }
1509
1510 return probes_per_objfile;
1511}
1512
1513/* Implementation of `sym_get_probe_argument_count', as documented in
1514 symfile.h. */
1515
1516static unsigned
6bac7473 1517elf_get_probe_argument_count (struct probe *probe)
55aa24fb 1518{
6bac7473 1519 return probe->pops->get_probe_argument_count (probe);
55aa24fb
SDJ
1520}
1521
25f9533e
SDJ
1522/* Implementation of `sym_can_evaluate_probe_arguments', as documented in
1523 symfile.h. */
1524
1525static int
1526elf_can_evaluate_probe_arguments (struct probe *probe)
1527{
1528 return probe->pops->can_evaluate_probe_arguments (probe);
1529}
1530
55aa24fb
SDJ
1531/* Implementation of `sym_evaluate_probe_argument', as documented in
1532 symfile.h. */
1533
1534static struct value *
6bac7473 1535elf_evaluate_probe_argument (struct probe *probe, unsigned n)
55aa24fb 1536{
6bac7473 1537 return probe->pops->evaluate_probe_argument (probe, n);
55aa24fb
SDJ
1538}
1539
1540/* Implementation of `sym_compile_to_ax', as documented in symfile.h. */
1541
1542static void
6bac7473 1543elf_compile_to_ax (struct probe *probe,
55aa24fb
SDJ
1544 struct agent_expr *expr,
1545 struct axs_value *value,
1546 unsigned n)
1547{
6bac7473 1548 probe->pops->compile_to_ax (probe, expr, value, n);
55aa24fb
SDJ
1549}
1550
1551/* Implementation of `sym_relocate_probe', as documented in symfile.h. */
1552
1553static void
1554elf_symfile_relocate_probe (struct objfile *objfile,
3189cb12
DE
1555 const struct section_offsets *new_offsets,
1556 const struct section_offsets *delta)
55aa24fb
SDJ
1557{
1558 int ix;
1559 VEC (probe_p) *probes = objfile_data (objfile, probe_key);
1560 struct probe *probe;
1561
1562 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
1563 probe->pops->relocate (probe, ANOFFSET (delta, SECT_OFF_TEXT (objfile)));
1564}
1565
1566/* Helper function used to free the space allocated for storing SystemTap
1567 probe information. */
1568
1569static void
1570probe_key_free (struct objfile *objfile, void *d)
1571{
1572 int ix;
1573 VEC (probe_p) *probes = d;
1574 struct probe *probe;
1575
1576 for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
1577 probe->pops->destroy (probe);
1578
1579 VEC_free (probe_p, probes);
1580}
1581
c906108c 1582\f
55aa24fb
SDJ
1583
1584/* Implementation `sym_probe_fns', as documented in symfile.h. */
1585
1586static const struct sym_probe_fns elf_probe_fns =
1587{
25f9533e
SDJ
1588 elf_get_probes, /* sym_get_probes */
1589 elf_get_probe_argument_count, /* sym_get_probe_argument_count */
1590 elf_can_evaluate_probe_arguments, /* sym_can_evaluate_probe_arguments */
1591 elf_evaluate_probe_argument, /* sym_evaluate_probe_argument */
1592 elf_compile_to_ax, /* sym_compile_to_ax */
1593 elf_symfile_relocate_probe, /* sym_relocate_probe */
55aa24fb
SDJ
1594};
1595
c906108c
SS
1596/* Register that we are able to handle ELF object file formats. */
1597
00b5771c 1598static const struct sym_fns elf_sym_fns =
c906108c 1599{
3e43a32a
MS
1600 elf_new_init, /* init anything gbl to entire symtab */
1601 elf_symfile_init, /* read initial info, setup for sym_read() */
1602 elf_symfile_read, /* read a symbol file into symtab */
b11896a5
TT
1603 NULL, /* sym_read_psymbols */
1604 elf_symfile_finish, /* finished with file, cleanup */
1605 default_symfile_offsets, /* Translate ext. to int. relocation */
1606 elf_symfile_segments, /* Get segment information from a file. */
1607 NULL,
1608 default_symfile_relocate, /* Relocate a debug section. */
55aa24fb 1609 &elf_probe_fns, /* sym_probe_fns */
b11896a5
TT
1610 &psym_functions
1611};
1612
1613/* The same as elf_sym_fns, but not registered and lazily reads
1614 psymbols. */
1615
1616static const struct sym_fns elf_sym_fns_lazy_psyms =
1617{
b11896a5
TT
1618 elf_new_init, /* init anything gbl to entire symtab */
1619 elf_symfile_init, /* read initial info, setup for sym_read() */
1620 elf_symfile_read, /* read a symbol file into symtab */
1621 read_psyms, /* sym_read_psymbols */
3e43a32a
MS
1622 elf_symfile_finish, /* finished with file, cleanup */
1623 default_symfile_offsets, /* Translate ext. to int. relocation */
1624 elf_symfile_segments, /* Get segment information from a file. */
1625 NULL,
1626 default_symfile_relocate, /* Relocate a debug section. */
55aa24fb 1627 &elf_probe_fns, /* sym_probe_fns */
00b5771c 1628 &psym_functions
c906108c
SS
1629};
1630
9291a0cd
TT
1631/* The same as elf_sym_fns, but not registered and uses the
1632 DWARF-specific GNU index rather than psymtab. */
00b5771c 1633static const struct sym_fns elf_sym_fns_gdb_index =
9291a0cd 1634{
3e43a32a
MS
1635 elf_new_init, /* init anything gbl to entire symab */
1636 elf_symfile_init, /* read initial info, setup for sym_red() */
1637 elf_symfile_read, /* read a symbol file into symtab */
b11896a5 1638 NULL, /* sym_read_psymbols */
3e43a32a
MS
1639 elf_symfile_finish, /* finished with file, cleanup */
1640 default_symfile_offsets, /* Translate ext. to int. relocatin */
1641 elf_symfile_segments, /* Get segment information from a file. */
1642 NULL,
1643 default_symfile_relocate, /* Relocate a debug section. */
55aa24fb 1644 &elf_probe_fns, /* sym_probe_fns */
00b5771c 1645 &dwarf2_gdb_index_functions
9291a0cd
TT
1646};
1647
07be84bf
JK
1648/* STT_GNU_IFUNC resolver vector to be installed to gnu_ifunc_fns_p. */
1649
1650static const struct gnu_ifunc_fns elf_gnu_ifunc_fns =
1651{
1652 elf_gnu_ifunc_resolve_addr,
1653 elf_gnu_ifunc_resolve_name,
0e30163f
JK
1654 elf_gnu_ifunc_resolver_stop,
1655 elf_gnu_ifunc_resolver_return_stop
07be84bf
JK
1656};
1657
c906108c 1658void
fba45db2 1659_initialize_elfread (void)
c906108c 1660{
55aa24fb 1661 probe_key = register_objfile_data_with_cleanup (NULL, probe_key_free);
c256e171 1662 add_symtab_fns (bfd_target_elf_flavour, &elf_sym_fns);
07be84bf
JK
1663
1664 elf_objfile_gnu_ifunc_cache_data = register_objfile_data ();
1665 gnu_ifunc_fns_p = &elf_gnu_ifunc_fns;
c906108c 1666}
This page took 1.00399 seconds and 4 git commands to generate.