1/* Read a symbol table in MIPS' format (Third-Eye). 2 3 Copyright (C) 1986-2023 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 "stabsread.h" 31#include "mdebugread.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 44static void 45read_alphacoff_dynamic_symtab (minimal_symbol_reader &, 46 struct objfile *objfile); 47 48/* Initialize anything that needs initializing when a completely new 49 symbol file is specified (not just adding some symbols from another 50 file, e.g. a shared library). */ 51 52static void 53mipscoff_new_init (struct objfile *ignore) 54{ 55 stabsread_new_init (); 56} 57 58/* Initialize to read a symbol file (nothing to do). */ 59 60static void 61mipscoff_symfile_init (struct objfile *objfile) 62{ 63} 64 65/* Read a symbol file from a file. */ 66 67static void 68mipscoff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags) 69{ 70 bfd *abfd = objfile->obfd.get (); 71 72 minimal_symbol_reader reader (objfile); 73 74 /* Now that the executable file is positioned at symbol table, 75 process it and define symbols accordingly. */ 76 77 if (!((*ecoff_backend (abfd)->debug_swap.read_debug_info) 78 (abfd, NULL, &ecoff_data (abfd)->debug_info))) 79 error (_("Error reading symbol table: %s"), bfd_errmsg (bfd_get_error ())); 80 81 mdebug_build_psymtabs (reader, objfile, &ecoff_backend (abfd)->debug_swap, 82 &ecoff_data (abfd)->debug_info); 83 84 /* Add alpha coff dynamic symbols. */ 85 86 read_alphacoff_dynamic_symtab (reader, objfile); 87 88 /* Install any minimal symbols that have been collected as the current 89 minimal symbols for this objfile. */ 90 91 reader.install (); 92} 93 94/* Perform any local cleanups required when we are done with a 95 particular objfile. */ 96 97static void 98mipscoff_symfile_finish (struct objfile *objfile) 99{ 100} 101 102/* Alpha OSF/1 encapsulates the dynamic symbols in ELF format in a 103 standard COFF section. The ELF format for the symbols differs from 104 the format defined in elf/external.h. It seems that a normal ELF 105 32-bit format is used, and the representation only changes because 106 longs are 64-bit on the alpha. In addition, the handling of 107 text/data section indices for symbols is different from the ELF 108 ABI. As the BFD linker currently does not support dynamic linking 109 on the alpha, there seems to be no reason to pollute BFD with 110 another mixture of object file formats for now. */ 111 112/* Format of an alpha external ELF symbol. */ 113 114typedef struct 115{ 116 unsigned char st_name[4]; /* Symbol name, index in string table. */ 117 unsigned char st_pad[4]; /* Pad to long word boundary. */ 118 unsigned char st_value[8]; /* Value of the symbol. */ 119 unsigned char st_size[4]; /* Associated symbol size. */ 120 unsigned char st_info[1]; /* Type and binding attributes. */ 121 unsigned char st_other[1]; /* No defined meaning, 0. */ 122 unsigned char st_shndx[2]; /* Associated section index. */ 123} Elfalpha_External_Sym; 124 125/* Format of an alpha external ELF dynamic info structure. */ 126 127typedef struct 128{ 129 unsigned char d_tag[4]; /* Tag. */ 130 unsigned char d_pad[4]; /* Pad to long word boundary. */ 131 union 132 { 133 unsigned char d_ptr[8]; /* Pointer value. */ 134 unsigned char d_val[4]; /* Integer value. */ 135 } 136 d_un; 137} Elfalpha_External_Dyn; 138 139/* Struct to obtain the section pointers for alpha dynamic symbol info. */ 140 141struct alphacoff_dynsecinfo 142{ 143 asection *sym_sect; /* Section pointer for .dynsym section. */ 144 asection *str_sect; /* Section pointer for .dynstr section. */ 145 asection *dyninfo_sect; /* Section pointer for .dynamic section. */ 146 asection *got_sect; /* Section pointer for .got section. */ 147}; 148 149/* We are called once per section from read_alphacoff_dynamic_symtab. 150 We need to examine each section we are passed, check to see if it 151 is something we are interested in processing, and if so, stash away 152 some access information for the section. */ 153 154static void 155alphacoff_locate_sections (bfd *ignore_abfd, asection *sectp, void *sip) 156{ 157 struct alphacoff_dynsecinfo *si; 158 159 si = (struct alphacoff_dynsecinfo *) sip; 160 161 if (strcmp (sectp->name, ".dynsym") == 0) 162 si->sym_sect = sectp; 163 else if (strcmp (sectp->name, ".dynstr") == 0) 164 si->str_sect = sectp; 165 else if (strcmp (sectp->name, ".dynamic") == 0) 166 si->dyninfo_sect = sectp; 167 else if (strcmp (sectp->name, ".got") == 0) 168 si->got_sect = sectp; 169} 170 171/* Scan an alpha dynamic symbol table for symbols of interest and add 172 them to the minimal symbol table. */ 173 174static void 175read_alphacoff_dynamic_symtab (minimal_symbol_reader &reader, 176 struct objfile *objfile) 177{ 178 bfd *abfd = objfile->obfd.get (); 179 struct alphacoff_dynsecinfo si; 180 int sym_count; 181 int i; 182 int stripped; 183 Elfalpha_External_Sym *x_symp; 184 gdb_byte *dyninfo_p; 185 gdb_byte *dyninfo_end; 186 int got_entry_size = 8; 187 int dt_mips_local_gotno = -1; 188 int dt_mips_gotsym = -1; 189 190 /* We currently only know how to handle alpha dynamic symbols. */ 191 if (bfd_get_arch (abfd) != bfd_arch_alpha) 192 return; 193 194 /* Locate the dynamic symbols sections and read them in. */ 195 memset ((char *) &si, 0, sizeof (si)); 196 bfd_map_over_sections (abfd, alphacoff_locate_sections, (void *) & si); 197 if (si.sym_sect == NULL || si.str_sect == NULL 198 || si.dyninfo_sect == NULL || si.got_sect == NULL) 199 return; 200 201 gdb::byte_vector sym_sec (bfd_section_size (si.sym_sect)); 202 gdb::byte_vector str_sec (bfd_section_size (si.str_sect)); 203 gdb::byte_vector dyninfo_sec (bfd_section_size (si.dyninfo_sect)); 204 gdb::byte_vector got_sec (bfd_section_size (si.got_sect)); 205 206 if (!bfd_get_section_contents (abfd, si.sym_sect, sym_sec.data (), 207 (file_ptr) 0, sym_sec.size ())) 208 return; 209 if (!bfd_get_section_contents (abfd, si.str_sect, str_sec.data (), 210 (file_ptr) 0, str_sec.size ())) 211 return; 212 if (!bfd_get_section_contents (abfd, si.dyninfo_sect, dyninfo_sec.data (), 213 (file_ptr) 0, dyninfo_sec.size ())) 214 return; 215 if (!bfd_get_section_contents (abfd, si.got_sect, got_sec.data (), 216 (file_ptr) 0, got_sec.size ())) 217 return; 218 219 /* Find the number of local GOT entries and the index for the 220 first dynamic symbol in the GOT. */ 221 for ((dyninfo_p = dyninfo_sec.data (), 222 dyninfo_end = dyninfo_p + dyninfo_sec.size ()); 223 dyninfo_p < dyninfo_end; 224 dyninfo_p += sizeof (Elfalpha_External_Dyn)) 225 { 226 Elfalpha_External_Dyn *x_dynp = (Elfalpha_External_Dyn *) dyninfo_p; 227 long dyn_tag; 228 229 dyn_tag = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_tag); 230 if (dyn_tag == DT_NULL) 231 break; 232 else if (dyn_tag == DT_MIPS_LOCAL_GOTNO) 233 { 234 if (dt_mips_local_gotno < 0) 235 dt_mips_local_gotno 236 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val); 237 } 238 else if (dyn_tag == DT_MIPS_GOTSYM) 239 { 240 if (dt_mips_gotsym < 0) 241 dt_mips_gotsym 242 = bfd_h_get_32 (abfd, (bfd_byte *) x_dynp->d_un.d_val); 243 } 244 } 245 if (dt_mips_local_gotno < 0 || dt_mips_gotsym < 0) 246 return; 247 248 /* Scan all dynamic symbols and enter them into the minimal symbol 249 table if appropriate. */ 250 sym_count = sym_sec.size () / sizeof (Elfalpha_External_Sym); 251 stripped = (bfd_get_symcount (abfd) == 0); 252 253 /* Skip first symbol, which is a null dummy. */ 254 for (i = 1, x_symp = (Elfalpha_External_Sym *) sym_sec.data () + 1; 255 i < sym_count; 256 i++, x_symp++) 257 { 258 unsigned long strx; 259 char *name; 260 bfd_vma sym_value; 261 unsigned char sym_info; 262 unsigned int sym_shndx; 263 int isglobal; 264 enum minimal_symbol_type ms_type; 265 266 strx = bfd_h_get_32 (abfd, (bfd_byte *) x_symp->st_name); 267 if (strx >= str_sec.size ()) 268 continue; 269 name = (char *) (str_sec.data () + strx); 270 if (*name == '\0' || *name == '.') 271 continue; 272 273 sym_value = bfd_h_get_64 (abfd, (bfd_byte *) x_symp->st_value); 274 sym_info = bfd_h_get_8 (abfd, (bfd_byte *) x_symp->st_info); 275 sym_shndx = bfd_h_get_16 (abfd, (bfd_byte *) x_symp->st_shndx); 276 if (sym_shndx >= (SHN_LORESERVE & 0xffff)) 277 sym_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff); 278 isglobal = (ELF_ST_BIND (sym_info) == STB_GLOBAL); 279 280 if (sym_shndx == SHN_UNDEF) 281 { 282 /* Handle undefined functions which are defined in a shared 283 library. */ 284 if (ELF_ST_TYPE (sym_info) != STT_FUNC 285 || ELF_ST_BIND (sym_info) != STB_GLOBAL) 286 continue; 287 288 ms_type = mst_solib_trampoline; 289 290 /* If sym_value is nonzero, it points to the shared library 291 trampoline entry, which is what we are looking for. 292 293 If sym_value is zero, then we have to get the GOT entry 294 for the symbol. 295 296 If the GOT entry is nonzero, it represents the quickstart 297 address of the function and we use that as the symbol 298 value. 299 300 If the GOT entry is zero, the function address has to be 301 resolved by the runtime loader before the executable is 302 started. We are unable to find any meaningful address 303 for these functions in the executable file, so we skip 304 them. */ 305 if (sym_value == 0) 306 { 307 int got_entry_offset = 308 (i - dt_mips_gotsym + dt_mips_local_gotno) * got_entry_size; 309 310 if (got_entry_offset < 0 311 || got_entry_offset >= got_sec.size ()) 312 continue; 313 sym_value = 314 bfd_h_get_64 (abfd, 315 (bfd_byte *) (got_sec.data () 316 + got_entry_offset)); 317 if (sym_value == 0) 318 continue; 319 } 320 } 321 else 322 { 323 /* Symbols defined in the executable itself. We only care 324 about them if this is a stripped executable, otherwise 325 they have been retrieved from the normal symbol table 326 already. */ 327 if (!stripped) 328 continue; 329 330 if (sym_shndx == SHN_MIPS_TEXT) 331 { 332 if (isglobal) 333 ms_type = mst_text; 334 else 335 ms_type = mst_file_text; 336 } 337 else if (sym_shndx == SHN_MIPS_DATA) 338 { 339 if (isglobal) 340 ms_type = mst_data; 341 else 342 ms_type = mst_file_data; 343 } 344 else if (sym_shndx == SHN_MIPS_ACOMMON) 345 { 346 if (isglobal) 347 ms_type = mst_bss; 348 else 349 ms_type = mst_file_bss; 350 } 351 else if (sym_shndx == SHN_ABS) 352 { 353 ms_type = mst_abs; 354 } 355 else 356 { 357 continue; 358 } 359 } 360 361 reader.record (name, sym_value, ms_type); 362 } 363} 364 365/* Initialization. */ 366 367static const struct sym_fns ecoff_sym_fns = 368{ 369 mipscoff_new_init, /* init anything gbl to entire symtab */ 370 mipscoff_symfile_init, /* read initial info, setup for sym_read() */ 371 mipscoff_symfile_read, /* read a symbol file into symtab */ 372 mipscoff_symfile_finish, /* finished with file, cleanup */ 373 default_symfile_offsets, /* dummy FIXME til implem sym reloc */ 374 default_symfile_segments, /* Get segment information from a file. */ 375 NULL, 376 default_symfile_relocate, /* Relocate a debug section. */ 377 NULL, /* sym_probe_fns */ 378}; 379 380void _initialize_mipsread (); 381void 382_initialize_mipsread () 383{ 384 add_symtab_fns (bfd_target_ecoff_flavour, &ecoff_sym_fns); 385} 386