GDB (xrefs)

/tmp/gdb-8.1/gdb/mipsread.c
Go to the documentation of this file.
1 /* Read a symbol table in MIPS' format (Third-Eye).
2
3 Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5 Contributed by Alessandro Forin (af@cs.cmu.edu) at CMU. Major work
6 by Per Bothner, John Gilmore and Ian Lance Taylor at Cygnus Support.
7
8 This file is part of GDB.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22
23 /* Read symbols from an ECOFF file. Most of the work is done in
24 mdebugread.c. */
25
26 #include "defs.h"
27 #include "bfd.h"
28 #include "symtab.h"
29 #include "objfiles.h"
30 #include "buildsym.h"
31 #include "stabsread.h"
32
33 #include "coff/sym.h"
34 #include "coff/internal.h"
35 #include "coff/ecoff.h"
36 #include "libcoff.h" /* Private BFD COFF information. */
37 #include "libecoff.h" /* Private BFD ECOFF information. */
38 #include "elf/common.h"
39 #include "elf/internal.h"
40 #include "elf/mips.h"
41
42 #include "psymtab.h"
43
44 static void
45 read_alphacoff_dynamic_symtab (minimal_symbol_reader &,
46 struct section_offsets *,
47 struct objfile *objfile);
48
49 /* Initialize anything that needs initializing when a completely new
50 symbol file is specified (not just adding some symbols from another
51 file, e.g. a shared library). */
52
53 static void
54 mipscoff_new_init (struct objfile *ignore)
55 {
56 stabsread_new_init ();
57 buildsym_new_init ();
58 }
59
60 /* Initialize to read a symbol file (nothing to do). */
61
62 static void
63 mipscoff_symfile_init (struct objfile *objfile)
64 {
65 }
66
67 /* Read a symbol file from a file. */
68
69 static void
70 mipscoff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
71 {
72 bfd *abfd = objfile->obfd;
73
74 minimal_symbol_reader reader (objfile);
75
76 /* Now that the executable file is positioned at symbol table,
77 process it and define symbols accordingly. */
78
79 if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info)
80 (abfd, (asection *) NULL, &ecoff_data (abfd)->debug_info)))
81 error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ()));
82
83 mdebug_build_psymtabs (reader, objfile, &ecoff_backend (abfd)->debug_swap,
84 &ecoff_data (abfd)->debug_info);
85
86 /* Add alpha coff dynamic symbols. */
87
88 read_alphacoff_dynamic_symtab (reader, objfile->section_offsets, objfile);
89
90 /* Install any minimal symbols that have been collected as the current
91 minimal symbols for this objfile. */
92
93 reader.install ();
94 }
95
96 /* Perform any local cleanups required when we are done with a
97 particular objfile. */
98
99 static void
100 mipscoff_symfile_finish (struct objfile *objfile)
101 {
102 }
103
104 /* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a
105 standard COFF section. The ELF format for the symbols differs from
106 the format defined in elf/external.h. It seems that a normal ELF
107 32-bit format is used, and the representation only changes because
108 longs are 64-bit on the alpha. In addition, the handling of
109 text/data section indices for symbols is different from the ELF
110 ABI. As the BFD linker currently does not support dynamic linking
111 on the alpha, there seems to be no reason to pollute BFD with
112 another mixture of object file formats for now. */
113
114 /* Format of an alpha external ELF symbol. */
115
116 typedef struct
117 {
118 unsigned char st_name[4]; /* Symbol name, index in string table. */
119 unsigned char st_pad[4]; /* Pad to long word boundary. */
120 unsigned char st_value[8]; /* Value of the symbol. */
121 unsigned char st_size[4]; /* Associated symbol size. */
122 unsigned char st_info[1]; /* Type and binding attributes. */
123 unsigned char st_other[1]; /* No defined meaning, 0. */
124 unsigned char st_shndx[2]; /* Associated section index. */
125 } Elfalpha_External_Sym;
126
127 /* Format of an alpha external ELF dynamic info structure. */
128
129 typedef struct
130 {
131 unsigned char d_tag[4]; /* Tag. */
132 unsigned char d_pad[4]; /* Pad to long word boundary. */
133 union
134 {
135 unsigned char d_ptr[8]; /* Pointer value. */
136 unsigned char d_val[4]; /* Integer value. */
137 }
138 d_un;
139 } Elfalpha_External_Dyn;
140
141 /* Struct to obtain the section pointers for alpha dynamic symbol info. */
142
143 struct alphacoff_dynsecinfo
144 {
145 asection *sym_sect; /* Section pointer for .dynsym section. */
146 asection *str_sect; /* Section pointer for .dynstr section. */
147 asection *dyninfo_sect; /* Section pointer for .dynamic section. */
148 asection *got_sect; /* Section pointer for .got section. */
149 };
150
151 /* We are called once per section from read_alphacoff_dynamic_symtab.
152 We need to examine each section we are passed, check to see if it
153 is something we are interested in processing, and if so, stash away
154 some access information for the section. */
155
156 static void
157 alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip)
158 {
159 struct alphacoff_dynsecinfo *si;
160
161 si = (struct alphacoff_dynsecinfo *) sip;
162
163 if (strcmp (sectp->name, ".dynsym") == 0)
164 si->sym_sect = sectp;
165 else if (strcmp (sectp->name, ".dynstr") == 0)
166 si->str_sect = sectp;
167 else if (strcmp (sectp->name, ".dynamic") == 0)
168 si->dyninfo_sect = sectp;
169 else if (strcmp (sectp->name, ".got") == 0)
170 si->got_sect = sectp;
171 }
172
173 /* Scan an alpha dynamic symbol table for symbols of interest and add
174 them to the minimal symbol table. */
175
176 static void
177 read_alphacoff_dynamic_symtab (minimal_symbol_reader &reader,
178 struct section_offsets *section_offsets,
179 struct objfile *objfile)
180 {
181 bfd *abfd = objfile->obfd;
182 struct alphacoff_dynsecinfo si;
183 char *sym_secptr;
184 char *str_secptr;
185 char *dyninfo_secptr;
186 char *got_secptr;
187 bfd_size_type sym_secsize;
188 bfd_size_type str_secsize;
189 bfd_size_type dyninfo_secsize;
190 bfd_size_type got_secsize;
191 int sym_count;
192 int i;
193 int stripped;
194 Elfalpha_External_Sym *x_symp;
195 char *dyninfo_p;
196 char *dyninfo_end;
197 int got_entry_size = 8;
198 int dt_mips_local_gotno = -1;
199 int dt_mips_gotsym = -1;
200 struct cleanup *cleanups;
201
202 /* We currently only know how to handle alpha dynamic symbols. */
203 if (bfd_get_arch (abfd) != bfd_arch_alpha)
204 return;
205
206 /* Locate the dynamic symbols sections and read them in. */
207 memset ((char *) &si, 0, sizeof (si));
208 bfd_map_over_sections (abfd, alphacoff_locate_sections, (void *) & si);
209 if (si.sym_sect == NULL || si.str_sect == NULL
210 || si.dyninfo_sect == NULL || si.got_sect == NULL)
211 return;
212
213 sym_secsize = bfd_get_section_size (si.sym_sect);
214 str_secsize = bfd_get_section_size (si.str_sect);
215 dyninfo_secsize = bfd_get_section_size (si.dyninfo_sect);
216 got_secsize = bfd_get_section_size (si.got_sect);
217 sym_secptr = (char *) xmalloc (sym_secsize);
218 cleanups = make_cleanup (xfree, sym_secptr);
219 str_secptr = (char *) xmalloc (str_secsize);
220 make_cleanup (xfree, str_secptr);
221 dyninfo_secptr = (char *) xmalloc (dyninfo_secsize);
222 make_cleanup (xfree, dyninfo_secptr);
223 got_secptr = (char *) xmalloc (got_secsize);
224 make_cleanup (xfree, got_secptr);
225
226 if (!bfd_get_section_contents (abfd, si.sym_sect, sym_secptr,
227 (file_ptr) 0, sym_secsize))
228 {
229 do_cleanups (cleanups);
230 return;
231 }
232 if (!bfd_get_section_contents (abfd, si.str_sect, str_secptr,
233 (file_ptr) 0, str_secsize))
234 {
235 do_cleanups (cleanups);
236 return;
237 }
238 if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_secptr,
239 (file_ptr) 0, dyninfo_secsize))
240 {
241 do_cleanups (cleanups);
242 return;
243 }
244 if (!bfd_get_section_contents (abfd, si.got_sect, got_secptr,
245 (file_ptr) 0, got_secsize))
246 {
247 do_cleanups (cleanups);
248 return;
249 }
250
251 /* Find the number of local GOT entries and the index for the
252 first dynamic symbol in the GOT. */
253 for (dyninfo_p = dyninfo_secptr, dyninfo_end = dyninfo_p + dyninfo_secsize;
254 dyninfo_p < dyninfo_end;
255 dyninfo_p += sizeof (Elfalpha_External_Dyn))
256 {
257 Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p;
258 long dyn_tag;
259
260 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag);
261 if (dyn_tag == DT_NULL)
262 break;
263 else if (dyn_tag == DT_MIPS_LOCAL_GOTNO)
264 {
265 if (dt_mips_local_gotno < 0)
266 dt_mips_local_gotno
267 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
268 }
269 else if (dyn_tag == DT_MIPS_GOTSYM)
270 {
271 if (dt_mips_gotsym < 0)
272 dt_mips_gotsym
273 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val);
274 }
275 }
276 if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0)
277 {
278 do_cleanups (cleanups);
279 return;
280 }
281
282 /* Scan all dynamic symbols and enter them into the minimal symbol
283 table if appropriate. */
284 sym_count = sym_secsize / sizeof (Elfalpha_External_Sym);
285 stripped = (bfd_get_symcount (abfd) == 0);
286
287 /* Skip first symbol, which is a null dummy. */
288 for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_secptr + 1;
289 i < sym_count;
290 i++, x_symp++)
291 {
292 unsigned long strx;
293 char *name;
294 bfd_vma sym_value;
295 unsigned char sym_info;
296 unsigned int sym_shndx;
297 int isglobal;
298 enum minimal_symbol_type ms_type;
299
300 strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name);
301 if (strx >= str_secsize)
302 continue;
303 name = str_secptr + strx;
304 if (*name == '\0' || *name == '.')
305 continue;
306
307 sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value);
308 sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info);
309 sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx);
310 if (sym_shndx >= (SHN_LORESERVE & 0xffff))
311 sym_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
312 isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL);
313
314 if (sym_shndx == SHN_UNDEF)
315 {
316 /* Handle undefined functions which are defined in a shared
317 library. */
318 if (ELF_ST_TYPE (sym_info) != STT_FUNC
319 || ELF_ST_BIND (sym_info) != STB_GLOBAL)
320 continue;
321
322 ms_type = mst_solib_trampoline;
323
324 /* If sym_value is nonzero, it points to the shared library
325 trampoline entry, which is what we are looking for.
326
327 If sym_value is zero, then we have to get the GOT entry
328 for the symbol.
329
330 If the GOT entry is nonzero, it represents the quickstart
331 address of the function and we use that as the symbol
332 value.
333
334 If the GOT entry is zero, the function address has to be
335 resolved by the runtime loader before the executable is
336 started. We are unable to find any meaningful address
337 for these functions in the executable file, so we skip
338 them. */
339 if (sym_value == 0)
340 {
341 int got_entry_offset =
342 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size;
343
344 if (got_entry_offset < 0 || got_entry_offset >= got_secsize)
345 continue;
346 sym_value =
347 bfd_h_get_64 (abfd,
348 (bfd_byte *) (got_secptr + got_entry_offset));
349 if (sym_value == 0)
350 continue;
351 }
352 }
353 else
354 {
355 /* Symbols defined in the executable itself. We only care
356 about them if this is a stripped executable, otherwise
357 they have been retrieved from the normal symbol table
358 already. */
359 if (!stripped)
360 continue;
361
362 if (sym_shndx == SHN_MIPS_TEXT)
363 {
364 if (isglobal)
365 ms_type = mst_text;
366 else
367 ms_type = mst_file_text;
368 }
369 else if (sym_shndx == SHN_MIPS_DATA)
370 {
371 if (isglobal)
372 ms_type = mst_data;
373 else
374 ms_type = mst_file_data;
375 }
376 else if (sym_shndx == SHN_MIPS_ACOMMON)
377 {
378 if (isglobal)
379 ms_type = mst_bss;
380 else
381 ms_type = mst_file_bss;
382 }
383 else if (sym_shndx == SHN_ABS)
384 {
385 ms_type = mst_abs;
386 }
387 else
388 {
389 continue;
390 }
391 }
392
393 reader.record (name, sym_value, ms_type);
394 }
395
396 do_cleanups (cleanups);
397 }
398
399 /* Initialization. */
400
401 static const struct sym_fns ecoff_sym_fns =
402 {
403 mipscoff_new_init, /* init anything gbl to entire symtab */
404 mipscoff_symfile_init, /* read initial info, setup for sym_read() */
405 mipscoff_symfile_read, /* read a symbol file into symtab */
406 NULL, /* sym_read_psymbols */
407 mipscoff_symfile_finish, /* finished with file, cleanup */
408 default_symfile_offsets, /* dummy FIXME til implem sym reloc */
409 default_symfile_segments, /* Get segment information from a file. */
410 NULL,
411 default_symfile_relocate, /* Relocate a debug section. */
412 NULL, /* sym_probe_fns */
413 &psym_functions
414 };
415
416 void
417 _initialize_mipsread (void)
418 {
419 add_symtab_fns (bfd_target_ecoff_flavour, &ecoff_sym_fns);
420 }
minimal_symbol_reader::install
void install()
Definition: minsyms.c:1346
stabsread_new_init
void stabsread_new_init(void)
Definition: stabsread.c:4769
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
Elfalpha_External_Dyn::d_val
unsigned char d_val[4]
Definition: mipsread.c:136
mst_bss
Definition: symtab.h:587
xfree
void xfree(void *)
minimal_symbol_reader::record
void record(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type)
Definition: minsyms.c:1085
if
if(!(yy_init))
Definition: ada-lex.c:1075
Elfalpha_External_Sym::st_value
unsigned char st_value[8]
Definition: mipsread.c:120
memset
void * memset(T *s, int c, size_t n)=delete
add_symtab_fns
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition: symfile.c:1790
default_symfile_segments
struct symfile_segment_data * default_symfile_segments(bfd *abfd)
Definition: symfile.c:785
read_alphacoff_dynamic_symtab
static void read_alphacoff_dynamic_symtab(minimal_symbol_reader &, struct section_offsets *, struct objfile *objfile)
Definition: mipsread.c:177
psymtab.h
mst_abs
Definition: symtab.h:588
Elfalpha_External_Dyn::d_tag
unsigned char d_tag[4]
Definition: mipsread.c:131
cleanup
Definition: cleanups.c:38
_
#define _(String)
Definition: gdb_locale.h:35
mst_file_data
Definition: symtab.h:601
defs.h
alphacoff_dynsecinfo
Definition: mipsread.c:143
objfiles.h
mdebug_build_psymtabs
void mdebug_build_psymtabs(minimal_symbol_reader &reader, struct objfile *objfile, const struct ecoff_debug_swap *swap, struct ecoff_debug_info *info)
Definition: mdebugread.c:338
ecoff_sym_fns
static const struct sym_fns ecoff_sym_fns
Definition: mipsread.c:401
symtab.h
mipscoff_new_init
static void mipscoff_new_init(struct objfile *ignore)
Definition: mipsread.c:54
name
const char *const name
Definition: aarch64-tdep.c:76
default_symfile_relocate
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3625
section_offsets
Definition: symtab.h:1271
Elfalpha_External_Dyn::d_un
union Elfalpha_External_Dyn::@96 d_un
sym_fns
Definition: symfile.h:302
mst_data
Definition: symtab.h:586
buildsym.h
Elfalpha_External_Sym::st_info
unsigned char st_info[1]
Definition: mipsread.c:122
buildsym_new_init
void buildsym_new_init(void)
Definition: buildsym.c:1779
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
debug_swap
static const struct ecoff_debug_swap * debug_swap
Definition: mdebugread.c:185
Elfalpha_External_Sym::st_name
unsigned char st_name[4]
Definition: mipsread.c:118
mipscoff_symfile_init
static void mipscoff_symfile_init(struct objfile *objfile)
Definition: mipsread.c:63
alphacoff_dynsecinfo::got_sect
asection * got_sect
Definition: mipsread.c:148
Elfalpha_External_Sym
Definition: mipsread.c:116
xmalloc
void * xmalloc(YYSIZE_T)
mipscoff_symfile_read
static void mipscoff_symfile_read(struct objfile *objfile, symfile_add_flags symfile_flags)
Definition: mipsread.c:70
objfile
Definition: objfiles.h:286
mipscoff_symfile_finish
static void mipscoff_symfile_finish(struct objfile *objfile)
Definition: mipsread.c:100
debug_info
static struct ecoff_debug_info * debug_info
Definition: mdebugread.c:189
stabsread.h
psym_functions
const struct quick_symbol_functions psym_functions
Definition: psymtab.c:1541
alphacoff_dynsecinfo::dyninfo_sect
asection * dyninfo_sect
Definition: mipsread.c:147
mst_text
Definition: symtab.h:582
default_symfile_offsets
void default_symfile_offsets(struct objfile *objfile, const struct section_addr_info *addrs)
Definition: symfile.c:695
mst_solib_trampoline
Definition: symtab.h:597
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
alphacoff_dynsecinfo::str_sect
asection * str_sect
Definition: mipsread.c:146
Elfalpha_External_Sym::st_shndx
unsigned char st_shndx[2]
Definition: mipsread.c:124
Elfalpha_External_Dyn
Definition: mipsread.c:129
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
mst_file_bss
Definition: symtab.h:602
minimal_symbol_type
minimal_symbol_type
Definition: symtab.h:579
minimal_symbol_reader
Definition: minsyms.h:62
error
void error(const char *fmt,...)
Definition: errors.c:38
_initialize_mipsread
void _initialize_mipsread(void)
Definition: mipsread.c:417
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
alphacoff_dynsecinfo::sym_sect
asection * sym_sect
Definition: mipsread.c:145
mst_file_text
Definition: symtab.h:600
alphacoff_locate_sections
static void alphacoff_locate_sections(bfd *ignore_abfd, asection *sectp, void *sip)
Definition: mipsread.c:157