1185029Spjd/* Read dbx symbol tables and convert to internal format, for GDB. 2185029Spjd Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 3185029Spjd 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004. 4185029Spjd Free Software Foundation, Inc. 5185029Spjd 6185029Spjd This file is part of GDB. 7185029Spjd 8185029Spjd This program is free software; you can redistribute it and/or modify 9185029Spjd it under the terms of the GNU General Public License as published by 10185029Spjd the Free Software Foundation; either version 2 of the License, or 11185029Spjd (at your option) any later version. 12185029Spjd 13185029Spjd This program is distributed in the hope that it will be useful, 14185029Spjd but WITHOUT ANY WARRANTY; without even the implied warranty of 15185029Spjd MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16185029Spjd GNU General Public License for more details. 17185029Spjd 18185029Spjd You should have received a copy of the GNU General Public License 19185029Spjd along with this program; if not, write to the Free Software 20185029Spjd Foundation, Inc., 59 Temple Place - Suite 330, 21185029Spjd Boston, MA 02111-1307, USA. */ 22219089Spjd 23185029Spjd/* This module provides three functions: dbx_symfile_init, 24185029Spjd which initializes to read a symbol file; dbx_new_init, which 25185029Spjd discards existing cached information when all symbols are being 26185029Spjd discarded; and dbx_symfile_read, which reads a symbol table 27185029Spjd from a file. 28185029Spjd 29185029Spjd dbx_symfile_read only does the minimum work necessary for letting the 30185029Spjd user "name" things symbolically; it does not read the entire symtab. 31185029Spjd Instead, it reads the external and static symbols and puts them in partial 32185029Spjd symbol tables. When more extensive information is requested of a 33185029Spjd file, the corresponding partial symbol table is mutated into a full 34185029Spjd fledged symbol table by going back and reading the symbols 35185029Spjd for real. dbx_psymtab_to_symtab() is the function that does this */ 36219089Spjd 37185029Spjd#include "defs.h" 38185029Spjd#include "gdb_string.h" 39185029Spjd 40185029Spjd#if defined(USG) || defined(__CYGNUSCLIB__) 41185029Spjd#include <sys/types.h> 42185029Spjd#include <fcntl.h> 43185029Spjd#endif 44185029Spjd 45185029Spjd#include "gdb_obstack.h" 46185029Spjd#include "gdb_stat.h" 47185029Spjd#include "symtab.h" 48185029Spjd#include "breakpoint.h" 49185029Spjd#include "target.h" 50185029Spjd#include "gdbcore.h" /* for bfd stuff */ 51185029Spjd#include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */ 52185029Spjd#include "objfiles.h" 53209962Smm#include "buildsym.h" 54185029Spjd#include "stabsread.h" 55209962Smm#include "gdb-stabs.h" 56209962Smm#include "demangle.h" 57209962Smm#include "language.h" /* Needed for local_hex_string */ 58185029Spjd#include "complaints.h" 59185029Spjd#include "cp-abi.h" 60185029Spjd#include "gdb_assert.h" 61185029Spjd 62185029Spjd#include "aout/aout64.h" 63185029Spjd#include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */ 64185029Spjd 65185029Spjd 66185029Spjd/* We put a pointer to this structure in the read_symtab_private field 67185029Spjd of the psymtab. */ 68185029Spjd 69185029Spjdstruct symloc 70185029Spjd { 71185029Spjd /* Offset within the file symbol table of first local symbol for this 72185029Spjd file. */ 73185029Spjd 74185029Spjd int ldsymoff; 75185029Spjd 76185029Spjd /* Length (in bytes) of the section of the symbol table devoted to 77185029Spjd this file's symbols (actually, the section bracketed may contain 78185029Spjd more than just this file's symbols). If ldsymlen is 0, the only 79185029Spjd reason for this thing's existence is the dependency list. Nothing 80185029Spjd else will happen when it is read in. */ 81185029Spjd 82185029Spjd int ldsymlen; 83185029Spjd 84185029Spjd /* The size of each symbol in the symbol file (in external form). */ 85185029Spjd 86185029Spjd int symbol_size; 87185029Spjd 88185029Spjd /* Further information needed to locate the symbols if they are in 89185029Spjd an ELF file. */ 90185029Spjd 91185029Spjd int symbol_offset; 92185029Spjd int string_offset; 93185029Spjd int file_string_offset; 94185029Spjd }; 95185029Spjd 96185029Spjd#define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff) 97185029Spjd#define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen) 98185029Spjd#define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private)) 99185029Spjd#define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size) 100185029Spjd#define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset) 101185029Spjd#define STRING_OFFSET(p) (SYMLOC(p)->string_offset) 102185029Spjd#define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset) 103185029Spjd 104219089Spjd 105219089Spjd/* Remember what we deduced to be the source language of this psymtab. */ 106185029Spjd 107185029Spjdstatic enum language psymtab_language = language_unknown; 108209962Smm 109185029Spjd/* The BFD for this file -- implicit parameter to next_symbol_text. */ 110209962Smm 111209962Smmstatic bfd *symfile_bfd; 112209962Smm 113185029Spjd/* The size of each symbol in the symbol file (in external form). 114209962Smm This is set by dbx_symfile_read when building psymtabs, and by 115185029Spjd dbx_psymtab_to_symtab when building symtabs. */ 116209962Smm 117209962Smmstatic unsigned symbol_size; 118209962Smm 119209962Smm/* This is the offset of the symbol table in the executable file. */ 120209962Smm 121185029Spjdstatic unsigned symbol_table_offset; 122185029Spjd 123185029Spjd/* This is the offset of the string table in the executable file. */ 124209962Smm 125185029Spjdstatic unsigned string_table_offset; 126185029Spjd 127185029Spjd/* For elf+stab executables, the n_strx field is not a simple index 128185029Spjd into the string table. Instead, each .o file has a base offset in 129185029Spjd the string table, and the associated symbols contain offsets from 130185029Spjd this base. The following two variables contain the base offset for 131185029Spjd the current and next .o files. */ 132185029Spjd 133static unsigned int file_string_table_offset; 134static unsigned int next_file_string_table_offset; 135 136/* .o and NLM files contain unrelocated addresses which are based at 137 0. When non-zero, this flag disables some of the special cases for 138 Solaris elf+stab text addresses at location 0. */ 139 140static int symfile_relocatable = 0; 141 142/* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are 143 relative to the function start address. */ 144 145static int block_address_function_relative = 0; 146 147/* The lowest text address we have yet encountered. This is needed 148 because in an a.out file, there is no header field which tells us 149 what address the program is actually going to be loaded at, so we 150 need to make guesses based on the symbols (which *are* relocated to 151 reflect the address it will be loaded at). */ 152 153static CORE_ADDR lowest_text_address; 154 155/* Non-zero if there is any line number info in the objfile. Prevents 156 end_psymtab from discarding an otherwise empty psymtab. */ 157 158static int has_line_numbers; 159 160/* Complaints about the symbols we have encountered. */ 161 162static void 163unknown_symtype_complaint (const char *arg1) 164{ 165 complaint (&symfile_complaints, "unknown symbol type %s", arg1); 166} 167 168static void 169lbrac_mismatch_complaint (int arg1) 170{ 171 complaint (&symfile_complaints, 172 "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1); 173} 174 175static void 176repeated_header_complaint (const char *arg1, int arg2) 177{ 178 complaint (&symfile_complaints, 179 "\"repeated\" header file %s not previously seen, at symtab pos %d", 180 arg1, arg2); 181} 182 183/* find_text_range --- find start and end of loadable code sections 184 185 The find_text_range function finds the shortest address range that 186 encloses all sections containing executable code, and stores it in 187 objfile's text_addr and text_size members. 188 189 dbx_symfile_read will use this to finish off the partial symbol 190 table, in some cases. */ 191 192static void 193find_text_range (bfd * sym_bfd, struct objfile *objfile) 194{ 195 asection *sec; 196 int found_any = 0; 197 CORE_ADDR start = 0; 198 CORE_ADDR end = 0; 199 200 for (sec = sym_bfd->sections; sec; sec = sec->next) 201 if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE) 202 { 203 CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec); 204 CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec); 205 206 if (found_any) 207 { 208 if (sec_start < start) 209 start = sec_start; 210 if (sec_end > end) 211 end = sec_end; 212 } 213 else 214 { 215 start = sec_start; 216 end = sec_end; 217 } 218 219 found_any = 1; 220 } 221 222 if (!found_any) 223 error ("Can't find any code sections in symbol file"); 224 225 DBX_TEXT_ADDR (objfile) = start; 226 DBX_TEXT_SIZE (objfile) = end - start; 227} 228 229 230 231/* During initial symbol readin, we need to have a structure to keep 232 track of which psymtabs have which bincls in them. This structure 233 is used during readin to setup the list of dependencies within each 234 partial symbol table. */ 235 236struct header_file_location 237{ 238 char *name; /* Name of header file */ 239 int instance; /* See above */ 240 struct partial_symtab *pst; /* Partial symtab that has the 241 BINCL/EINCL defs for this file */ 242}; 243 244/* The actual list and controling variables */ 245static struct header_file_location *bincl_list, *next_bincl; 246static int bincls_allocated; 247 248/* Local function prototypes */ 249 250extern void _initialize_dbxread (void); 251 252static void read_ofile_symtab (struct partial_symtab *); 253 254static void dbx_psymtab_to_symtab (struct partial_symtab *); 255 256static void dbx_psymtab_to_symtab_1 (struct partial_symtab *); 257 258static void read_dbx_dynamic_symtab (struct objfile *objfile); 259 260static void read_dbx_symtab (struct objfile *); 261 262static void free_bincl_list (struct objfile *); 263 264static struct partial_symtab *find_corresponding_bincl_psymtab (char *, int); 265 266static void add_bincl_to_list (struct partial_symtab *, char *, int); 267 268static void init_bincl_list (int, struct objfile *); 269 270static char *dbx_next_symbol_text (struct objfile *); 271 272static void fill_symbuf (bfd *); 273 274static void dbx_symfile_init (struct objfile *); 275 276static void dbx_new_init (struct objfile *); 277 278static void dbx_symfile_read (struct objfile *, int); 279 280static void dbx_symfile_finish (struct objfile *); 281 282static void record_minimal_symbol (char *, CORE_ADDR, int, struct objfile *); 283 284static void add_new_header_file (char *, int); 285 286static void add_old_header_file (char *, int); 287 288static void add_this_object_header_file (int); 289 290static struct partial_symtab *start_psymtab (struct objfile *, char *, 291 CORE_ADDR, int, 292 struct partial_symbol **, 293 struct partial_symbol **); 294 295/* Free up old header file tables */ 296 297void 298free_header_files (void) 299{ 300 if (this_object_header_files) 301 { 302 xfree (this_object_header_files); 303 this_object_header_files = NULL; 304 } 305 n_allocated_this_object_header_files = 0; 306} 307 308/* Allocate new header file tables */ 309 310void 311init_header_files (void) 312{ 313 n_allocated_this_object_header_files = 10; 314 this_object_header_files = (int *) xmalloc (10 * sizeof (int)); 315} 316 317/* Add header file number I for this object file 318 at the next successive FILENUM. */ 319 320static void 321add_this_object_header_file (int i) 322{ 323 if (n_this_object_header_files == n_allocated_this_object_header_files) 324 { 325 n_allocated_this_object_header_files *= 2; 326 this_object_header_files 327 = (int *) xrealloc ((char *) this_object_header_files, 328 n_allocated_this_object_header_files * sizeof (int)); 329 } 330 331 this_object_header_files[n_this_object_header_files++] = i; 332} 333 334/* Add to this file an "old" header file, one already seen in 335 a previous object file. NAME is the header file's name. 336 INSTANCE is its instance code, to select among multiple 337 symbol tables for the same header file. */ 338 339static void 340add_old_header_file (char *name, int instance) 341{ 342 struct header_file *p = HEADER_FILES (current_objfile); 343 int i; 344 345 for (i = 0; i < N_HEADER_FILES (current_objfile); i++) 346 if (strcmp (p[i].name, name) == 0 && instance == p[i].instance) 347 { 348 add_this_object_header_file (i); 349 return; 350 } 351 repeated_header_complaint (name, symnum); 352} 353 354/* Add to this file a "new" header file: definitions for its types follow. 355 NAME is the header file's name. 356 Most often this happens only once for each distinct header file, 357 but not necessarily. If it happens more than once, INSTANCE has 358 a different value each time, and references to the header file 359 use INSTANCE values to select among them. 360 361 dbx output contains "begin" and "end" markers for each new header file, 362 but at this level we just need to know which files there have been; 363 so we record the file when its "begin" is seen and ignore the "end". */ 364 365static void 366add_new_header_file (char *name, int instance) 367{ 368 int i; 369 struct header_file *hfile; 370 371 /* Make sure there is room for one more header file. */ 372 373 i = N_ALLOCATED_HEADER_FILES (current_objfile); 374 375 if (N_HEADER_FILES (current_objfile) == i) 376 { 377 if (i == 0) 378 { 379 N_ALLOCATED_HEADER_FILES (current_objfile) = 10; 380 HEADER_FILES (current_objfile) = (struct header_file *) 381 xmalloc (10 * sizeof (struct header_file)); 382 } 383 else 384 { 385 i *= 2; 386 N_ALLOCATED_HEADER_FILES (current_objfile) = i; 387 HEADER_FILES (current_objfile) = (struct header_file *) 388 xrealloc ((char *) HEADER_FILES (current_objfile), 389 (i * sizeof (struct header_file))); 390 } 391 } 392 393 /* Create an entry for this header file. */ 394 395 i = N_HEADER_FILES (current_objfile)++; 396 hfile = HEADER_FILES (current_objfile) + i; 397 hfile->name = savestring (name, strlen (name)); 398 hfile->instance = instance; 399 hfile->length = 10; 400 hfile->vector 401 = (struct type **) xmalloc (10 * sizeof (struct type *)); 402 memset (hfile->vector, 0, 10 * sizeof (struct type *)); 403 404 add_this_object_header_file (i); 405} 406 407#if 0 408static struct type ** 409explicit_lookup_type (int real_filenum, int index) 410{ 411 struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum]; 412 413 if (index >= f->length) 414 { 415 f->length *= 2; 416 f->vector = (struct type **) 417 xrealloc (f->vector, f->length * sizeof (struct type *)); 418 memset (&f->vector[f->length / 2], 419 '\0', f->length * sizeof (struct type *) / 2); 420 } 421 return &f->vector[index]; 422} 423#endif 424 425static void 426record_minimal_symbol (char *name, CORE_ADDR address, int type, 427 struct objfile *objfile) 428{ 429 enum minimal_symbol_type ms_type; 430 int section; 431 asection *bfd_section; 432 433 switch (type) 434 { 435 case N_TEXT | N_EXT: 436 ms_type = mst_text; 437 section = SECT_OFF_TEXT (objfile); 438 bfd_section = DBX_TEXT_SECTION (objfile); 439 break; 440 case N_DATA | N_EXT: 441 ms_type = mst_data; 442 section = SECT_OFF_DATA (objfile); 443 bfd_section = DBX_DATA_SECTION (objfile); 444 break; 445 case N_BSS | N_EXT: 446 ms_type = mst_bss; 447 section = SECT_OFF_BSS (objfile); 448 bfd_section = DBX_BSS_SECTION (objfile); 449 break; 450 case N_ABS | N_EXT: 451 ms_type = mst_abs; 452 section = -1; 453 bfd_section = NULL; 454 break; 455#ifdef N_SETV 456 case N_SETV | N_EXT: 457 ms_type = mst_data; 458 section = SECT_OFF_DATA (objfile); 459 bfd_section = DBX_DATA_SECTION (objfile); 460 break; 461 case N_SETV: 462 /* I don't think this type actually exists; since a N_SETV is the result 463 of going over many .o files, it doesn't make sense to have one 464 file local. */ 465 ms_type = mst_file_data; 466 section = SECT_OFF_DATA (objfile); 467 bfd_section = DBX_DATA_SECTION (objfile); 468 break; 469#endif 470 case N_TEXT: 471 case N_NBTEXT: 472 case N_FN: 473 case N_FN_SEQ: 474 ms_type = mst_file_text; 475 section = SECT_OFF_TEXT (objfile); 476 bfd_section = DBX_TEXT_SECTION (objfile); 477 break; 478 case N_DATA: 479 ms_type = mst_file_data; 480 481 /* Check for __DYNAMIC, which is used by Sun shared libraries. 482 Record it as global even if it's local, not global, so 483 lookup_minimal_symbol can find it. We don't check symbol_leading_char 484 because for SunOS4 it always is '_'. */ 485 if (name[8] == 'C' && DEPRECATED_STREQ ("__DYNAMIC", name)) 486 ms_type = mst_data; 487 488 /* Same with virtual function tables, both global and static. */ 489 { 490 char *tempstring = name; 491 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd)) 492 ++tempstring; 493 if (is_vtable_name (tempstring)) 494 ms_type = mst_data; 495 } 496 section = SECT_OFF_DATA (objfile); 497 bfd_section = DBX_DATA_SECTION (objfile); 498 break; 499 case N_BSS: 500 ms_type = mst_file_bss; 501 section = SECT_OFF_BSS (objfile); 502 bfd_section = DBX_BSS_SECTION (objfile); 503 break; 504 default: 505 ms_type = mst_unknown; 506 section = -1; 507 bfd_section = NULL; 508 break; 509 } 510 511 if ((ms_type == mst_file_text || ms_type == mst_text) 512 && address < lowest_text_address) 513 lowest_text_address = address; 514 515 prim_record_minimal_symbol_and_info 516 (name, address, ms_type, NULL, section, bfd_section, objfile); 517} 518 519/* Scan and build partial symbols for a symbol file. 520 We have been initialized by a call to dbx_symfile_init, which 521 put all the relevant info into a "struct dbx_symfile_info", 522 hung off the objfile structure. 523 524 MAINLINE is true if we are reading the main symbol 525 table (as opposed to a shared lib or dynamically loaded file). */ 526 527static void 528dbx_symfile_read (struct objfile *objfile, int mainline) 529{ 530 bfd *sym_bfd; 531 int val; 532 struct cleanup *back_to; 533 534 sym_bfd = objfile->obfd; 535 536 /* .o and .nlm files are relocatables with text, data and bss segs based at 537 0. This flag disables special (Solaris stabs-in-elf only) fixups for 538 symbols with a value of 0. */ 539 540 symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC; 541 542 /* This is true for Solaris (and all other systems which put stabs 543 in sections, hopefully, since it would be silly to do things 544 differently from Solaris), and false for SunOS4 and other a.out 545 file formats. */ 546 block_address_function_relative = 547 ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3)) 548 || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3)) 549 || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4)) 550 || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2)) 551 || (0 == strncmp (bfd_get_target (sym_bfd), "epoc-pe", 7)) 552 || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3))); 553 554 val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET); 555 if (val < 0) 556 perror_with_name (objfile->name); 557 558 /* If we are reinitializing, or if we have never loaded syms yet, init */ 559 if (mainline 560 || (objfile->global_psymbols.size == 0 561 && objfile->static_psymbols.size == 0)) 562 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile)); 563 564 symbol_size = DBX_SYMBOL_SIZE (objfile); 565 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile); 566 567 free_pending_blocks (); 568 back_to = make_cleanup (really_free_pendings, 0); 569 570 init_minimal_symbol_collection (); 571 make_cleanup_discard_minimal_symbols (); 572 573 /* Read stabs data from executable file and define symbols. */ 574 575 read_dbx_symtab (objfile); 576 577 /* Add the dynamic symbols. */ 578 579 read_dbx_dynamic_symtab (objfile); 580 581 /* Install any minimal symbols that have been collected as the current 582 minimal symbols for this objfile. */ 583 584 install_minimal_symbols (objfile); 585 586 do_cleanups (back_to); 587} 588 589/* Initialize anything that needs initializing when a completely new 590 symbol file is specified (not just adding some symbols from another 591 file, e.g. a shared library). */ 592 593static void 594dbx_new_init (struct objfile *ignore) 595{ 596 stabsread_new_init (); 597 buildsym_new_init (); 598 init_header_files (); 599} 600 601 602/* dbx_symfile_init () 603 is the dbx-specific initialization routine for reading symbols. 604 It is passed a struct objfile which contains, among other things, 605 the BFD for the file whose symbols are being read, and a slot for a pointer 606 to "private data" which we fill with goodies. 607 608 We read the string table into malloc'd space and stash a pointer to it. 609 610 Since BFD doesn't know how to read debug symbols in a format-independent 611 way (and may never do so...), we have to do it ourselves. We will never 612 be called unless this is an a.out (or very similar) file. 613 FIXME, there should be a cleaner peephole into the BFD environment here. */ 614 615#define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */ 616 617static void 618dbx_symfile_init (struct objfile *objfile) 619{ 620 int val; 621 bfd *sym_bfd = objfile->obfd; 622 char *name = bfd_get_filename (sym_bfd); 623 asection *text_sect; 624 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE]; 625 626 /* Allocate struct to keep track of the symfile */ 627 objfile->sym_stab_info = (struct dbx_symfile_info *) 628 xmmalloc (objfile->md, sizeof (struct dbx_symfile_info)); 629 memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info)); 630 631 DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text"); 632 DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data"); 633 DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss"); 634 635 /* FIXME POKING INSIDE BFD DATA STRUCTURES */ 636#define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd)) 637#define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd)) 638 639 /* FIXME POKING INSIDE BFD DATA STRUCTURES */ 640 641 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL; 642 643 text_sect = bfd_get_section_by_name (sym_bfd, ".text"); 644 if (!text_sect) 645 error ("Can't find .text section in symbol file"); 646 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect); 647 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect); 648 649 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd); 650 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd); 651 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET; 652 653 /* Read the string table and stash it away in the objfile_obstack. 654 When we blow away the objfile the string table goes away as well. 655 Note that gdb used to use the results of attempting to malloc the 656 string table, based on the size it read, as a form of sanity check 657 for botched byte swapping, on the theory that a byte swapped string 658 table size would be so totally bogus that the malloc would fail. Now 659 that we put in on the objfile_obstack, we can't do this since gdb gets 660 a fatal error (out of virtual memory) if the size is bogus. We can 661 however at least check to see if the size is less than the size of 662 the size field itself, or larger than the size of the entire file. 663 Note that all valid string tables have a size greater than zero, since 664 the bytes used to hold the size are included in the count. */ 665 666 if (STRING_TABLE_OFFSET == 0) 667 { 668 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET 669 will never be zero, even when there is no string table. This 670 would appear to be a bug in bfd. */ 671 DBX_STRINGTAB_SIZE (objfile) = 0; 672 DBX_STRINGTAB (objfile) = NULL; 673 } 674 else 675 { 676 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET); 677 if (val < 0) 678 perror_with_name (name); 679 680 memset (size_temp, 0, sizeof (size_temp)); 681 val = bfd_bread (size_temp, sizeof (size_temp), sym_bfd); 682 if (val < 0) 683 { 684 perror_with_name (name); 685 } 686 else if (val == 0) 687 { 688 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to 689 EOF if there is no string table, and attempting to read the size 690 from EOF will read zero bytes. */ 691 DBX_STRINGTAB_SIZE (objfile) = 0; 692 DBX_STRINGTAB (objfile) = NULL; 693 } 694 else 695 { 696 /* Read some data that would appear to be the string table size. 697 If there really is a string table, then it is probably the right 698 size. Byteswap if necessary and validate the size. Note that 699 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some 700 random data that happened to be at STRING_TABLE_OFFSET, because 701 bfd can't tell us there is no string table, the sanity checks may 702 or may not catch this. */ 703 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp); 704 705 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp) 706 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd)) 707 error ("ridiculous string table size (%d bytes).", 708 DBX_STRINGTAB_SIZE (objfile)); 709 710 DBX_STRINGTAB (objfile) = 711 (char *) obstack_alloc (&objfile->objfile_obstack, 712 DBX_STRINGTAB_SIZE (objfile)); 713 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile)); 714 715 /* Now read in the string table in one big gulp. */ 716 717 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET); 718 if (val < 0) 719 perror_with_name (name); 720 val = bfd_bread (DBX_STRINGTAB (objfile), 721 DBX_STRINGTAB_SIZE (objfile), 722 sym_bfd); 723 if (val != DBX_STRINGTAB_SIZE (objfile)) 724 perror_with_name (name); 725 } 726 } 727} 728 729/* Perform any local cleanups required when we are done with a particular 730 objfile. I.E, we are in the process of discarding all symbol information 731 for an objfile, freeing up all memory held for it, and unlinking the 732 objfile struct from the global list of known objfiles. */ 733 734static void 735dbx_symfile_finish (struct objfile *objfile) 736{ 737 if (objfile->sym_stab_info != NULL) 738 { 739 if (HEADER_FILES (objfile) != NULL) 740 { 741 int i = N_HEADER_FILES (objfile); 742 struct header_file *hfiles = HEADER_FILES (objfile); 743 744 while (--i >= 0) 745 { 746 xfree (hfiles[i].name); 747 xfree (hfiles[i].vector); 748 } 749 xfree (hfiles); 750 } 751 xmfree (objfile->md, objfile->sym_stab_info); 752 } 753 free_header_files (); 754} 755 756 757/* Buffer for reading the symbol table entries. */ 758static struct external_nlist symbuf[4096]; 759static int symbuf_idx; 760static int symbuf_end; 761 762/* Name of last function encountered. Used in Solaris to approximate 763 object file boundaries. */ 764static char *last_function_name; 765 766/* The address in memory of the string table of the object file we are 767 reading (which might not be the "main" object file, but might be a 768 shared library or some other dynamically loaded thing). This is 769 set by read_dbx_symtab when building psymtabs, and by 770 read_ofile_symtab when building symtabs, and is used only by 771 next_symbol_text. FIXME: If that is true, we don't need it when 772 building psymtabs, right? */ 773static char *stringtab_global; 774 775/* These variables are used to control fill_symbuf when the stabs 776 symbols are not contiguous (as may be the case when a COFF file is 777 linked using --split-by-reloc). */ 778static struct stab_section_list *symbuf_sections; 779static unsigned int symbuf_left; 780static unsigned int symbuf_read; 781 782/* This variable stores a global stabs buffer, if we read stabs into 783 memory in one chunk in order to process relocations. */ 784static bfd_byte *stabs_data; 785 786/* Refill the symbol table input buffer 787 and set the variables that control fetching entries from it. 788 Reports an error if no data available. 789 This function can read past the end of the symbol table 790 (into the string table) but this does no harm. */ 791 792static void 793fill_symbuf (bfd *sym_bfd) 794{ 795 unsigned int count; 796 int nbytes; 797 798 if (stabs_data) 799 { 800 nbytes = sizeof (symbuf); 801 if (nbytes > symbuf_left) 802 nbytes = symbuf_left; 803 memcpy (symbuf, stabs_data + symbuf_read, nbytes); 804 } 805 else if (symbuf_sections == NULL) 806 { 807 count = sizeof (symbuf); 808 nbytes = bfd_bread (symbuf, count, sym_bfd); 809 } 810 else 811 { 812 if (symbuf_left <= 0) 813 { 814 file_ptr filepos = symbuf_sections->section->filepos; 815 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0) 816 perror_with_name (bfd_get_filename (sym_bfd)); 817 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section); 818 symbol_table_offset = filepos - symbuf_read; 819 symbuf_sections = symbuf_sections->next; 820 } 821 822 count = symbuf_left; 823 if (count > sizeof (symbuf)) 824 count = sizeof (symbuf); 825 nbytes = bfd_bread (symbuf, count, sym_bfd); 826 } 827 828 if (nbytes < 0) 829 perror_with_name (bfd_get_filename (sym_bfd)); 830 else if (nbytes == 0) 831 error ("Premature end of file reading symbol table"); 832 symbuf_end = nbytes / symbol_size; 833 symbuf_idx = 0; 834 symbuf_left -= nbytes; 835 symbuf_read += nbytes; 836} 837 838static void 839stabs_seek (int sym_offset) 840{ 841 if (stabs_data) 842 { 843 symbuf_read += sym_offset; 844 symbuf_left -= sym_offset; 845 } 846 else 847 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR); 848} 849 850#define INTERNALIZE_SYMBOL(intern, extern, abfd) \ 851 { \ 852 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \ 853 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \ 854 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \ 855 if (bfd_get_sign_extend_vma (abfd)) \ 856 (intern).n_value = bfd_h_get_signed_32 (abfd, (extern)->e_value); \ 857 else \ 858 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \ 859 } 860 861/* Invariant: The symbol pointed to by symbuf_idx is the first one 862 that hasn't been swapped. Swap the symbol at the same time 863 that symbuf_idx is incremented. */ 864 865/* dbx allows the text of a symbol name to be continued into the 866 next symbol name! When such a continuation is encountered 867 (a \ at the end of the text of a name) 868 call this function to get the continuation. */ 869 870static char * 871dbx_next_symbol_text (struct objfile *objfile) 872{ 873 struct internal_nlist nlist; 874 875 if (symbuf_idx == symbuf_end) 876 fill_symbuf (symfile_bfd); 877 878 symnum++; 879 INTERNALIZE_SYMBOL (nlist, &symbuf[symbuf_idx], symfile_bfd); 880 OBJSTAT (objfile, n_stabs++); 881 882 symbuf_idx++; 883 884 return nlist.n_strx + stringtab_global + file_string_table_offset; 885} 886 887/* Initialize the list of bincls to contain none and have some 888 allocated. */ 889 890static void 891init_bincl_list (int number, struct objfile *objfile) 892{ 893 bincls_allocated = number; 894 next_bincl = bincl_list = (struct header_file_location *) 895 xmmalloc (objfile->md, bincls_allocated * sizeof (struct header_file_location)); 896} 897 898/* Add a bincl to the list. */ 899 900static void 901add_bincl_to_list (struct partial_symtab *pst, char *name, int instance) 902{ 903 if (next_bincl >= bincl_list + bincls_allocated) 904 { 905 int offset = next_bincl - bincl_list; 906 bincls_allocated *= 2; 907 bincl_list = (struct header_file_location *) 908 xmrealloc (pst->objfile->md, (char *) bincl_list, 909 bincls_allocated * sizeof (struct header_file_location)); 910 next_bincl = bincl_list + offset; 911 } 912 next_bincl->pst = pst; 913 next_bincl->instance = instance; 914 next_bincl++->name = name; 915} 916 917/* Given a name, value pair, find the corresponding 918 bincl in the list. Return the partial symtab associated 919 with that header_file_location. */ 920 921static struct partial_symtab * 922find_corresponding_bincl_psymtab (char *name, int instance) 923{ 924 struct header_file_location *bincl; 925 926 for (bincl = bincl_list; bincl < next_bincl; bincl++) 927 if (bincl->instance == instance 928 && strcmp (name, bincl->name) == 0) 929 return bincl->pst; 930 931 repeated_header_complaint (name, symnum); 932 return (struct partial_symtab *) 0; 933} 934 935/* Free the storage allocated for the bincl list. */ 936 937static void 938free_bincl_list (struct objfile *objfile) 939{ 940 xmfree (objfile->md, bincl_list); 941 bincls_allocated = 0; 942} 943 944static void 945do_free_bincl_list_cleanup (void *objfile) 946{ 947 free_bincl_list (objfile); 948} 949 950static struct cleanup * 951make_cleanup_free_bincl_list (struct objfile *objfile) 952{ 953 return make_cleanup (do_free_bincl_list_cleanup, objfile); 954} 955 956/* Set namestring based on nlist. If the string table index is invalid, 957 give a fake name, and print a single error message per symbol file read, 958 rather than abort the symbol reading or flood the user with messages. */ 959 960static char * 961set_namestring (struct objfile *objfile, struct internal_nlist nlist) 962{ 963 char *namestring; 964 965 if (((unsigned) nlist.n_strx + file_string_table_offset) >= 966 DBX_STRINGTAB_SIZE (objfile)) 967 { 968 complaint (&symfile_complaints, "bad string table offset in symbol %d", 969 symnum); 970 namestring = "<bad string table offset>"; 971 } 972 else 973 namestring = nlist.n_strx + file_string_table_offset + 974 DBX_STRINGTAB (objfile); 975 return namestring; 976} 977 978/* Scan a SunOs dynamic symbol table for symbols of interest and 979 add them to the minimal symbol table. */ 980 981static void 982read_dbx_dynamic_symtab (struct objfile *objfile) 983{ 984 bfd *abfd = objfile->obfd; 985 struct cleanup *back_to; 986 int counter; 987 long dynsym_size; 988 long dynsym_count; 989 asymbol **dynsyms; 990 asymbol **symptr; 991 arelent **relptr; 992 long dynrel_size; 993 long dynrel_count; 994 arelent **dynrels; 995 CORE_ADDR sym_value; 996 char *name; 997 998 /* Check that the symbol file has dynamic symbols that we know about. 999 bfd_arch_unknown can happen if we are reading a sun3 symbol file 1000 on a sun4 host (and vice versa) and bfd is not configured 1001 --with-target=all. This would trigger an assertion in bfd/sunos.c, 1002 so we ignore the dynamic symbols in this case. */ 1003 if (bfd_get_flavour (abfd) != bfd_target_aout_flavour 1004 || (bfd_get_file_flags (abfd) & DYNAMIC) == 0 1005 || bfd_get_arch (abfd) == bfd_arch_unknown) 1006 return; 1007 1008 dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd); 1009 if (dynsym_size < 0) 1010 return; 1011 1012 dynsyms = (asymbol **) xmalloc (dynsym_size); 1013 back_to = make_cleanup (xfree, dynsyms); 1014 1015 dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms); 1016 if (dynsym_count < 0) 1017 { 1018 do_cleanups (back_to); 1019 return; 1020 } 1021 1022 /* Enter dynamic symbols into the minimal symbol table 1023 if this is a stripped executable. */ 1024 if (bfd_get_symcount (abfd) <= 0) 1025 { 1026 symptr = dynsyms; 1027 for (counter = 0; counter < dynsym_count; counter++, symptr++) 1028 { 1029 asymbol *sym = *symptr; 1030 asection *sec; 1031 int type; 1032 1033 sec = bfd_get_section (sym); 1034 1035 /* BFD symbols are section relative. */ 1036 sym_value = sym->value + sec->vma; 1037 1038 if (bfd_get_section_flags (abfd, sec) & SEC_CODE) 1039 { 1040 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1041 type = N_TEXT; 1042 } 1043 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA) 1044 { 1045 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 1046 type = N_DATA; 1047 } 1048 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) 1049 { 1050 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 1051 type = N_BSS; 1052 } 1053 else 1054 continue; 1055 1056 if (sym->flags & BSF_GLOBAL) 1057 type |= N_EXT; 1058 1059 record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value, 1060 type, objfile); 1061 } 1062 } 1063 1064 /* Symbols from shared libraries have a dynamic relocation entry 1065 that points to the associated slot in the procedure linkage table. 1066 We make a mininal symbol table entry with type mst_solib_trampoline 1067 at the address in the procedure linkage table. */ 1068 dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd); 1069 if (dynrel_size < 0) 1070 { 1071 do_cleanups (back_to); 1072 return; 1073 } 1074 1075 dynrels = (arelent **) xmalloc (dynrel_size); 1076 make_cleanup (xfree, dynrels); 1077 1078 dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms); 1079 if (dynrel_count < 0) 1080 { 1081 do_cleanups (back_to); 1082 return; 1083 } 1084 1085 for (counter = 0, relptr = dynrels; 1086 counter < dynrel_count; 1087 counter++, relptr++) 1088 { 1089 arelent *rel = *relptr; 1090 CORE_ADDR address = 1091 rel->address + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 1092 1093 switch (bfd_get_arch (abfd)) 1094 { 1095 case bfd_arch_sparc: 1096 if (rel->howto->type != RELOC_JMP_SLOT) 1097 continue; 1098 break; 1099 case bfd_arch_m68k: 1100 /* `16' is the type BFD produces for a jump table relocation. */ 1101 if (rel->howto->type != 16) 1102 continue; 1103 1104 /* Adjust address in the jump table to point to 1105 the start of the bsr instruction. */ 1106 address -= 2; 1107 break; 1108 default: 1109 continue; 1110 } 1111 1112 name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr); 1113 prim_record_minimal_symbol (name, address, mst_solib_trampoline, 1114 objfile); 1115 } 1116 1117 do_cleanups (back_to); 1118} 1119 1120#ifdef SOFUN_ADDRESS_MAYBE_MISSING 1121static CORE_ADDR 1122find_stab_function_addr (char *namestring, char *filename, 1123 struct objfile *objfile) 1124{ 1125 struct minimal_symbol *msym; 1126 char *p; 1127 int n; 1128 1129 p = strchr (namestring, ':'); 1130 if (p == NULL) 1131 p = namestring; 1132 n = p - namestring; 1133 p = alloca (n + 2); 1134 strncpy (p, namestring, n); 1135 p[n] = 0; 1136 1137 msym = lookup_minimal_symbol (p, filename, objfile); 1138 if (msym == NULL) 1139 { 1140 /* Sun Fortran appends an underscore to the minimal symbol name, 1141 try again with an appended underscore if the minimal symbol 1142 was not found. */ 1143 p[n] = '_'; 1144 p[n + 1] = 0; 1145 msym = lookup_minimal_symbol (p, filename, objfile); 1146 } 1147 1148 if (msym == NULL && filename != NULL) 1149 { 1150 /* Try again without the filename. */ 1151 p[n] = 0; 1152 msym = lookup_minimal_symbol (p, NULL, objfile); 1153 } 1154 if (msym == NULL && filename != NULL) 1155 { 1156 /* And try again for Sun Fortran, but without the filename. */ 1157 p[n] = '_'; 1158 p[n + 1] = 0; 1159 msym = lookup_minimal_symbol (p, NULL, objfile); 1160 } 1161 1162 return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym); 1163} 1164#endif /* SOFUN_ADDRESS_MAYBE_MISSING */ 1165 1166static void 1167function_outside_compilation_unit_complaint (const char *arg1) 1168{ 1169 complaint (&symfile_complaints, 1170 "function `%s' appears to be defined outside of all compilation units", 1171 arg1); 1172} 1173 1174/* Setup partial_symtab's describing each source file for which 1175 debugging information is available. */ 1176 1177static void 1178read_dbx_symtab (struct objfile *objfile) 1179{ 1180 struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */ 1181 struct internal_nlist nlist; 1182 CORE_ADDR text_addr; 1183 int text_size; 1184 1185 char *namestring; 1186 int nsl; 1187 int past_first_source_file = 0; 1188 CORE_ADDR last_o_file_start = 0; 1189 CORE_ADDR last_function_start = 0; 1190 struct cleanup *back_to; 1191 bfd *abfd; 1192 int textlow_not_set; 1193 int data_sect_index; 1194 1195 /* Current partial symtab */ 1196 struct partial_symtab *pst; 1197 1198 /* List of current psymtab's include files */ 1199 char **psymtab_include_list; 1200 int includes_allocated; 1201 int includes_used; 1202 1203 /* Index within current psymtab dependency list */ 1204 struct partial_symtab **dependency_list; 1205 int dependencies_used, dependencies_allocated; 1206 1207 text_addr = DBX_TEXT_ADDR (objfile); 1208 text_size = DBX_TEXT_SIZE (objfile); 1209 1210 /* FIXME. We probably want to change stringtab_global rather than add this 1211 while processing every symbol entry. FIXME. */ 1212 file_string_table_offset = 0; 1213 next_file_string_table_offset = 0; 1214 1215 stringtab_global = DBX_STRINGTAB (objfile); 1216 1217 pst = (struct partial_symtab *) 0; 1218 1219 includes_allocated = 30; 1220 includes_used = 0; 1221 psymtab_include_list = (char **) alloca (includes_allocated * 1222 sizeof (char *)); 1223 1224 dependencies_allocated = 30; 1225 dependencies_used = 0; 1226 dependency_list = 1227 (struct partial_symtab **) alloca (dependencies_allocated * 1228 sizeof (struct partial_symtab *)); 1229 1230 /* Init bincl list */ 1231 init_bincl_list (20, objfile); 1232 back_to = make_cleanup_free_bincl_list (objfile); 1233 1234 last_source_file = NULL; 1235 1236 lowest_text_address = (CORE_ADDR) -1; 1237 1238 symfile_bfd = objfile->obfd; /* For next_text_symbol */ 1239 abfd = objfile->obfd; 1240 symbuf_end = symbuf_idx = 0; 1241 next_symbol_text_func = dbx_next_symbol_text; 1242 textlow_not_set = 1; 1243 has_line_numbers = 0; 1244 1245 /* FIXME: jimb/2003-09-12: We don't apply the right section's offset 1246 to global and static variables. The stab for a global or static 1247 variable doesn't give us any indication of which section it's in, 1248 so we can't tell immediately which offset in 1249 objfile->section_offsets we should apply to the variable's 1250 address. 1251 1252 We could certainly find out which section contains the variable 1253 by looking up the variable's unrelocated address with 1254 find_pc_section, but that would be expensive; this is the 1255 function that constructs the partial symbol tables by examining 1256 every symbol in the entire executable, and it's 1257 performance-critical. So that expense would not be welcome. I'm 1258 not sure what to do about this at the moment. 1259 1260 What we have done for years is to simply assume that the .data 1261 section's offset is appropriate for all global and static 1262 variables. Recently, this was expanded to fall back to the .bss 1263 section's offset if there is no .data section, and then to the 1264 .rodata section's offset. */ 1265 data_sect_index = objfile->sect_index_data; 1266 if (data_sect_index == -1) 1267 data_sect_index = SECT_OFF_BSS (objfile); 1268 if (data_sect_index == -1) 1269 data_sect_index = SECT_OFF_RODATA (objfile); 1270 1271 /* If data_sect_index is still -1, that's okay. It's perfectly fine 1272 for the file to have no .data, no .bss, and no .text at all, if 1273 it also has no global or static variables. If it does, we will 1274 get an internal error from an ANOFFSET macro below when we try to 1275 use data_sect_index. */ 1276 1277 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++) 1278 { 1279 /* Get the symbol for this run and pull out some info */ 1280 QUIT; /* allow this to be interruptable */ 1281 if (symbuf_idx == symbuf_end) 1282 fill_symbuf (abfd); 1283 bufp = &symbuf[symbuf_idx++]; 1284 1285 /* 1286 * Special case to speed up readin. 1287 */ 1288 if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE) 1289 { 1290 has_line_numbers = 1; 1291 continue; 1292 } 1293 1294 INTERNALIZE_SYMBOL (nlist, bufp, abfd); 1295 OBJSTAT (objfile, n_stabs++); 1296 1297 /* Ok. There is a lot of code duplicated in the rest of this 1298 switch statement (for efficiency reasons). Since I don't 1299 like duplicating code, I will do my penance here, and 1300 describe the code which is duplicated: 1301 1302 *) The assignment to namestring. 1303 *) The call to strchr. 1304 *) The addition of a partial symbol the the two partial 1305 symbol lists. This last is a large section of code, so 1306 I've imbedded it in the following macro. 1307 */ 1308 1309 switch (nlist.n_type) 1310 { 1311 char *p; 1312 /* 1313 * Standard, external, non-debugger, symbols 1314 */ 1315 1316 case N_TEXT | N_EXT: 1317 case N_NBTEXT | N_EXT: 1318 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1319 goto record_it; 1320 1321 case N_DATA | N_EXT: 1322 case N_NBDATA | N_EXT: 1323 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 1324 goto record_it; 1325 1326 case N_BSS: 1327 case N_BSS | N_EXT: 1328 case N_NBBSS | N_EXT: 1329 case N_SETV | N_EXT: /* FIXME, is this in BSS? */ 1330 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 1331 goto record_it; 1332 1333 case N_ABS | N_EXT: 1334 record_it: 1335 namestring = set_namestring (objfile, nlist); 1336 1337 bss_ext_symbol: 1338 record_minimal_symbol (namestring, nlist.n_value, 1339 nlist.n_type, objfile); /* Always */ 1340 continue; 1341 1342 /* Standard, local, non-debugger, symbols */ 1343 1344 case N_NBTEXT: 1345 1346 /* We need to be able to deal with both N_FN or N_TEXT, 1347 because we have no way of knowing whether the sys-supplied ld 1348 or GNU ld was used to make the executable. Sequents throw 1349 in another wrinkle -- they renumbered N_FN. */ 1350 1351 case N_FN: 1352 case N_FN_SEQ: 1353 case N_TEXT: 1354 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1355 namestring = set_namestring (objfile, nlist); 1356 1357 if ((namestring[0] == '-' && namestring[1] == 'l') 1358 || (namestring[(nsl = strlen (namestring)) - 1] == 'o' 1359 && namestring[nsl - 2] == '.')) 1360 { 1361 if (objfile->ei.entry_point < nlist.n_value && 1362 objfile->ei.entry_point >= last_o_file_start) 1363 { 1364 objfile->ei.deprecated_entry_file_lowpc = last_o_file_start; 1365 objfile->ei.deprecated_entry_file_highpc = nlist.n_value; 1366 } 1367 if (past_first_source_file && pst 1368 /* The gould NP1 uses low values for .o and -l symbols 1369 which are not the address. */ 1370 && nlist.n_value >= pst->textlow) 1371 { 1372 end_psymtab (pst, psymtab_include_list, includes_used, 1373 symnum * symbol_size, 1374 nlist.n_value > pst->texthigh 1375 ? nlist.n_value : pst->texthigh, 1376 dependency_list, dependencies_used, textlow_not_set); 1377 pst = (struct partial_symtab *) 0; 1378 includes_used = 0; 1379 dependencies_used = 0; 1380 } 1381 else 1382 past_first_source_file = 1; 1383 last_o_file_start = nlist.n_value; 1384 } 1385 else 1386 goto record_it; 1387 continue; 1388 1389 case N_DATA: 1390 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 1391 goto record_it; 1392 1393 case N_UNDF | N_EXT: 1394 if (nlist.n_value != 0) 1395 { 1396 /* This is a "Fortran COMMON" symbol. See if the target 1397 environment knows where it has been relocated to. */ 1398 1399 CORE_ADDR reladdr; 1400 1401 namestring = set_namestring (objfile, nlist); 1402 if (target_lookup_symbol (namestring, &reladdr)) 1403 { 1404 continue; /* Error in lookup; ignore symbol for now. */ 1405 } 1406 nlist.n_type ^= (N_BSS ^ N_UNDF); /* Define it as a bss-symbol */ 1407 nlist.n_value = reladdr; 1408 goto bss_ext_symbol; 1409 } 1410 continue; /* Just undefined, not COMMON */ 1411 1412 case N_UNDF: 1413 if (processing_acc_compilation && nlist.n_strx == 1) 1414 { 1415 /* Deal with relative offsets in the string table 1416 used in ELF+STAB under Solaris. If we want to use the 1417 n_strx field, which contains the name of the file, 1418 we must adjust file_string_table_offset *before* calling 1419 set_namestring(). */ 1420 past_first_source_file = 1; 1421 file_string_table_offset = next_file_string_table_offset; 1422 next_file_string_table_offset = 1423 file_string_table_offset + nlist.n_value; 1424 if (next_file_string_table_offset < file_string_table_offset) 1425 error ("string table offset backs up at %d", symnum); 1426 /* FIXME -- replace error() with complaint. */ 1427 continue; 1428 } 1429 continue; 1430 1431 /* Lots of symbol types we can just ignore. */ 1432 1433 case N_ABS: 1434 case N_NBDATA: 1435 case N_NBBSS: 1436 continue; 1437 1438 /* Keep going . . . */ 1439 1440 /* 1441 * Special symbol types for GNU 1442 */ 1443 case N_INDR: 1444 case N_INDR | N_EXT: 1445 case N_SETA: 1446 case N_SETA | N_EXT: 1447 case N_SETT: 1448 case N_SETT | N_EXT: 1449 case N_SETD: 1450 case N_SETD | N_EXT: 1451 case N_SETB: 1452 case N_SETB | N_EXT: 1453 case N_SETV: 1454 continue; 1455 1456 /* 1457 * Debugger symbols 1458 */ 1459 1460 case N_SO: 1461 { 1462 CORE_ADDR valu; 1463 static int prev_so_symnum = -10; 1464 static int first_so_symnum; 1465 char *p; 1466 int prev_textlow_not_set; 1467 1468 valu = nlist.n_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1469 1470 prev_textlow_not_set = textlow_not_set; 1471 1472#ifdef SOFUN_ADDRESS_MAYBE_MISSING 1473 /* A zero value is probably an indication for the SunPRO 3.0 1474 compiler. end_psymtab explicitly tests for zero, so 1475 don't relocate it. */ 1476 1477 if (nlist.n_value == 0) 1478 { 1479 textlow_not_set = 1; 1480 valu = 0; 1481 } 1482 else 1483 textlow_not_set = 0; 1484#else 1485 textlow_not_set = 0; 1486#endif 1487 past_first_source_file = 1; 1488 1489 if (prev_so_symnum != symnum - 1) 1490 { /* Here if prev stab wasn't N_SO */ 1491 first_so_symnum = symnum; 1492 1493 if (pst) 1494 { 1495 end_psymtab (pst, psymtab_include_list, includes_used, 1496 symnum * symbol_size, 1497 valu > pst->texthigh ? valu : pst->texthigh, 1498 dependency_list, dependencies_used, 1499 prev_textlow_not_set); 1500 pst = (struct partial_symtab *) 0; 1501 includes_used = 0; 1502 dependencies_used = 0; 1503 } 1504 } 1505 1506 prev_so_symnum = symnum; 1507 1508 /* End the current partial symtab and start a new one */ 1509 1510 namestring = set_namestring (objfile, nlist); 1511 1512 /* Null name means end of .o file. Don't start a new one. */ 1513 if (*namestring == '\000') 1514 continue; 1515 1516 /* Some compilers (including gcc) emit a pair of initial N_SOs. 1517 The first one is a directory name; the second the file name. 1518 If pst exists, is empty, and has a filename ending in '/', 1519 we assume the previous N_SO was a directory name. */ 1520 1521 p = strrchr (namestring, '/'); 1522 if (p && *(p + 1) == '\000') 1523 continue; /* Simply ignore directory name SOs */ 1524 1525 /* Some other compilers (C++ ones in particular) emit useless 1526 SOs for non-existant .c files. We ignore all subsequent SOs that 1527 immediately follow the first. */ 1528 1529 if (!pst) 1530 pst = start_psymtab (objfile, 1531 namestring, valu, 1532 first_so_symnum * symbol_size, 1533 objfile->global_psymbols.next, 1534 objfile->static_psymbols.next); 1535 continue; 1536 } 1537 1538 case N_BINCL: 1539 { 1540 enum language tmp_language; 1541 /* Add this bincl to the bincl_list for future EXCLs. No 1542 need to save the string; it'll be around until 1543 read_dbx_symtab function returns */ 1544 1545 namestring = set_namestring (objfile, nlist); 1546 tmp_language = deduce_language_from_filename (namestring); 1547 1548 /* Only change the psymtab's language if we've learned 1549 something useful (eg. tmp_language is not language_unknown). 1550 In addition, to match what start_subfile does, never change 1551 from C++ to C. */ 1552 if (tmp_language != language_unknown 1553 && (tmp_language != language_c 1554 || psymtab_language != language_cplus)) 1555 psymtab_language = tmp_language; 1556 1557 if (pst == NULL) 1558 { 1559 /* FIXME: we should not get here without a PST to work on. 1560 Attempt to recover. */ 1561 complaint (&symfile_complaints, 1562 "N_BINCL %s not in entries for any file, at symtab pos %d", 1563 namestring, symnum); 1564 continue; 1565 } 1566 add_bincl_to_list (pst, namestring, nlist.n_value); 1567 1568 /* Mark down an include file in the current psymtab */ 1569 1570 goto record_include_file; 1571 } 1572 1573 case N_SOL: 1574 { 1575 enum language tmp_language; 1576 /* Mark down an include file in the current psymtab */ 1577 1578 namestring = set_namestring (objfile, nlist); 1579 tmp_language = deduce_language_from_filename (namestring); 1580 1581 /* Only change the psymtab's language if we've learned 1582 something useful (eg. tmp_language is not language_unknown). 1583 In addition, to match what start_subfile does, never change 1584 from C++ to C. */ 1585 if (tmp_language != language_unknown 1586 && (tmp_language != language_c 1587 || psymtab_language != language_cplus)) 1588 psymtab_language = tmp_language; 1589 1590 /* In C++, one may expect the same filename to come round many 1591 times, when code is coming alternately from the main file 1592 and from inline functions in other files. So I check to see 1593 if this is a file we've seen before -- either the main 1594 source file, or a previously included file. 1595 1596 This seems to be a lot of time to be spending on N_SOL, but 1597 things like "break c-exp.y:435" need to work (I 1598 suppose the psymtab_include_list could be hashed or put 1599 in a binary tree, if profiling shows this is a major hog). */ 1600 if (pst && strcmp (namestring, pst->filename) == 0) 1601 continue; 1602 { 1603 int i; 1604 for (i = 0; i < includes_used; i++) 1605 if (strcmp (namestring, psymtab_include_list[i]) == 0) 1606 { 1607 i = -1; 1608 break; 1609 } 1610 if (i == -1) 1611 continue; 1612 } 1613 1614 record_include_file: 1615 1616 psymtab_include_list[includes_used++] = namestring; 1617 if (includes_used >= includes_allocated) 1618 { 1619 char **orig = psymtab_include_list; 1620 1621 psymtab_include_list = (char **) 1622 alloca ((includes_allocated *= 2) * 1623 sizeof (char *)); 1624 memcpy (psymtab_include_list, orig, 1625 includes_used * sizeof (char *)); 1626 } 1627 continue; 1628 } 1629 case N_LSYM: /* Typedef or automatic variable. */ 1630 case N_STSYM: /* Data seg var -- static */ 1631 case N_LCSYM: /* BSS " */ 1632 case N_ROSYM: /* Read-only data seg var -- static. */ 1633 case N_NBSTS: /* Gould nobase. */ 1634 case N_NBLCS: /* symbols. */ 1635 case N_FUN: 1636 case N_GSYM: /* Global (extern) variable; can be 1637 data or bss (sigh FIXME). */ 1638 1639 /* Following may probably be ignored; I'll leave them here 1640 for now (until I do Pascal and Modula 2 extensions). */ 1641 1642 case N_PC: /* I may or may not need this; I 1643 suspect not. */ 1644 case N_M2C: /* I suspect that I can ignore this here. */ 1645 case N_SCOPE: /* Same. */ 1646 1647 namestring = set_namestring (objfile, nlist); 1648 1649 /* See if this is an end of function stab. */ 1650 if (pst && nlist.n_type == N_FUN && *namestring == '\000') 1651 { 1652 CORE_ADDR valu; 1653 1654 /* It's value is the size (in bytes) of the function for 1655 function relative stabs, or the address of the function's 1656 end for old style stabs. */ 1657 valu = nlist.n_value + last_function_start; 1658 if (pst->texthigh == 0 || valu > pst->texthigh) 1659 pst->texthigh = valu; 1660 break; 1661 } 1662 1663 p = (char *) strchr (namestring, ':'); 1664 if (!p) 1665 continue; /* Not a debugging symbol. */ 1666 1667 1668 1669 /* Main processing section for debugging symbols which 1670 the initial read through the symbol tables needs to worry 1671 about. If we reach this point, the symbol which we are 1672 considering is definitely one we are interested in. 1673 p must also contain the (valid) index into the namestring 1674 which indicates the debugging type symbol. */ 1675 1676 switch (p[1]) 1677 { 1678 case 'S': 1679 nlist.n_value += ANOFFSET (objfile->section_offsets, data_sect_index); 1680#ifdef STATIC_TRANSFORM_NAME 1681 namestring = STATIC_TRANSFORM_NAME (namestring); 1682#endif 1683 add_psymbol_to_list (namestring, p - namestring, 1684 VAR_DOMAIN, LOC_STATIC, 1685 &objfile->static_psymbols, 1686 0, nlist.n_value, 1687 psymtab_language, objfile); 1688 continue; 1689 case 'G': 1690 nlist.n_value += ANOFFSET (objfile->section_offsets, data_sect_index); 1691 /* The addresses in these entries are reported to be 1692 wrong. See the code that reads 'G's for symtabs. */ 1693 add_psymbol_to_list (namestring, p - namestring, 1694 VAR_DOMAIN, LOC_STATIC, 1695 &objfile->global_psymbols, 1696 0, nlist.n_value, 1697 psymtab_language, objfile); 1698 continue; 1699 1700 case 'T': 1701 /* When a 'T' entry is defining an anonymous enum, it 1702 may have a name which is the empty string, or a 1703 single space. Since they're not really defining a 1704 symbol, those shouldn't go in the partial symbol 1705 table. We do pick up the elements of such enums at 1706 'check_enum:', below. */ 1707 if (p >= namestring + 2 1708 || (p == namestring + 1 1709 && namestring[0] != ' ')) 1710 { 1711 add_psymbol_to_list (namestring, p - namestring, 1712 STRUCT_DOMAIN, LOC_TYPEDEF, 1713 &objfile->static_psymbols, 1714 nlist.n_value, 0, 1715 psymtab_language, objfile); 1716 if (p[2] == 't') 1717 { 1718 /* Also a typedef with the same name. */ 1719 add_psymbol_to_list (namestring, p - namestring, 1720 VAR_DOMAIN, LOC_TYPEDEF, 1721 &objfile->static_psymbols, 1722 nlist.n_value, 0, 1723 psymtab_language, objfile); 1724 p += 1; 1725 } 1726 } 1727 goto check_enum; 1728 case 't': 1729 if (p != namestring) /* a name is there, not just :T... */ 1730 { 1731 add_psymbol_to_list (namestring, p - namestring, 1732 VAR_DOMAIN, LOC_TYPEDEF, 1733 &objfile->static_psymbols, 1734 nlist.n_value, 0, 1735 psymtab_language, objfile); 1736 } 1737 check_enum: 1738 /* If this is an enumerated type, we need to 1739 add all the enum constants to the partial symbol 1740 table. This does not cover enums without names, e.g. 1741 "enum {a, b} c;" in C, but fortunately those are 1742 rare. There is no way for GDB to find those from the 1743 enum type without spending too much time on it. Thus 1744 to solve this problem, the compiler needs to put out the 1745 enum in a nameless type. GCC2 does this. */ 1746 1747 /* We are looking for something of the form 1748 <name> ":" ("t" | "T") [<number> "="] "e" 1749 {<constant> ":" <value> ","} ";". */ 1750 1751 /* Skip over the colon and the 't' or 'T'. */ 1752 p += 2; 1753 /* This type may be given a number. Also, numbers can come 1754 in pairs like (0,26). Skip over it. */ 1755 while ((*p >= '0' && *p <= '9') 1756 || *p == '(' || *p == ',' || *p == ')' 1757 || *p == '=') 1758 p++; 1759 1760 if (*p++ == 'e') 1761 { 1762 /* The aix4 compiler emits extra crud before the members. */ 1763 if (*p == '-') 1764 { 1765 /* Skip over the type (?). */ 1766 while (*p != ':') 1767 p++; 1768 1769 /* Skip over the colon. */ 1770 p++; 1771 } 1772 1773 /* We have found an enumerated type. */ 1774 /* According to comments in read_enum_type 1775 a comma could end it instead of a semicolon. 1776 I don't know where that happens. 1777 Accept either. */ 1778 while (*p && *p != ';' && *p != ',') 1779 { 1780 char *q; 1781 1782 /* Check for and handle cretinous dbx symbol name 1783 continuation! */ 1784 if (*p == '\\' || (*p == '?' && p[1] == '\0')) 1785 p = next_symbol_text (objfile); 1786 1787 /* Point to the character after the name 1788 of the enum constant. */ 1789 for (q = p; *q && *q != ':'; q++) 1790 ; 1791 /* Note that the value doesn't matter for 1792 enum constants in psymtabs, just in symtabs. */ 1793 add_psymbol_to_list (p, q - p, 1794 VAR_DOMAIN, LOC_CONST, 1795 &objfile->static_psymbols, 0, 1796 0, psymtab_language, objfile); 1797 /* Point past the name. */ 1798 p = q; 1799 /* Skip over the value. */ 1800 while (*p && *p != ',') 1801 p++; 1802 /* Advance past the comma. */ 1803 if (*p) 1804 p++; 1805 } 1806 } 1807 continue; 1808 case 'c': 1809 /* Constant, e.g. from "const" in Pascal. */ 1810 add_psymbol_to_list (namestring, p - namestring, 1811 VAR_DOMAIN, LOC_CONST, 1812 &objfile->static_psymbols, nlist.n_value, 1813 0, psymtab_language, objfile); 1814 continue; 1815 1816 case 'f': 1817 if (! pst) 1818 { 1819 int name_len = p - namestring; 1820 char *name = xmalloc (name_len + 1); 1821 memcpy (name, namestring, name_len); 1822 name[name_len] = '\0'; 1823 function_outside_compilation_unit_complaint (name); 1824 xfree (name); 1825 } 1826 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1827 /* Kludges for ELF/STABS with Sun ACC */ 1828 last_function_name = namestring; 1829#ifdef SOFUN_ADDRESS_MAYBE_MISSING 1830 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit 1831 value for the bottom of the text seg in those cases. */ 1832 if (nlist.n_value == ANOFFSET (objfile->section_offsets, 1833 SECT_OFF_TEXT (objfile))) 1834 { 1835 CORE_ADDR minsym_valu = 1836 find_stab_function_addr (namestring, pst->filename, objfile); 1837 /* find_stab_function_addr will return 0 if the minimal 1838 symbol wasn't found. (Unfortunately, this might also 1839 be a valid address.) Anyway, if it *does* return 0, 1840 it is likely that the value was set correctly to begin 1841 with... */ 1842 if (minsym_valu != 0) 1843 nlist.n_value = minsym_valu; 1844 } 1845 if (pst && textlow_not_set) 1846 { 1847 pst->textlow = nlist.n_value; 1848 textlow_not_set = 0; 1849 } 1850#endif 1851 /* End kludge. */ 1852 1853 /* Keep track of the start of the last function so we 1854 can handle end of function symbols. */ 1855 last_function_start = nlist.n_value; 1856 1857 /* In reordered executables this function may lie outside 1858 the bounds created by N_SO symbols. If that's the case 1859 use the address of this function as the low bound for 1860 the partial symbol table. */ 1861 if (pst 1862 && (textlow_not_set 1863 || (nlist.n_value < pst->textlow 1864 && (nlist.n_value 1865 != ANOFFSET (objfile->section_offsets, 1866 SECT_OFF_TEXT (objfile)))))) 1867 { 1868 pst->textlow = nlist.n_value; 1869 textlow_not_set = 0; 1870 } 1871 add_psymbol_to_list (namestring, p - namestring, 1872 VAR_DOMAIN, LOC_BLOCK, 1873 &objfile->static_psymbols, 1874 0, nlist.n_value, 1875 psymtab_language, objfile); 1876 continue; 1877 1878 /* Global functions were ignored here, but now they 1879 are put into the global psymtab like one would expect. 1880 They're also in the minimal symbol table. */ 1881 case 'F': 1882 if (! pst) 1883 { 1884 int name_len = p - namestring; 1885 char *name = xmalloc (name_len + 1); 1886 memcpy (name, namestring, name_len); 1887 name[name_len] = '\0'; 1888 function_outside_compilation_unit_complaint (name); 1889 xfree (name); 1890 } 1891 nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1892 /* Kludges for ELF/STABS with Sun ACC */ 1893 last_function_name = namestring; 1894#ifdef SOFUN_ADDRESS_MAYBE_MISSING 1895 /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit 1896 value for the bottom of the text seg in those cases. */ 1897 if (nlist.n_value == ANOFFSET (objfile->section_offsets, 1898 SECT_OFF_TEXT (objfile))) 1899 { 1900 CORE_ADDR minsym_valu = 1901 find_stab_function_addr (namestring, pst->filename, objfile); 1902 /* find_stab_function_addr will return 0 if the minimal 1903 symbol wasn't found. (Unfortunately, this might also 1904 be a valid address.) Anyway, if it *does* return 0, 1905 it is likely that the value was set correctly to begin 1906 with... */ 1907 if (minsym_valu != 0) 1908 nlist.n_value = minsym_valu; 1909 } 1910 if (pst && textlow_not_set) 1911 { 1912 pst->textlow = nlist.n_value; 1913 textlow_not_set = 0; 1914 } 1915#endif 1916 /* End kludge. */ 1917 1918 /* Keep track of the start of the last function so we 1919 can handle end of function symbols. */ 1920 last_function_start = nlist.n_value; 1921 1922 /* In reordered executables this function may lie outside 1923 the bounds created by N_SO symbols. If that's the case 1924 use the address of this function as the low bound for 1925 the partial symbol table. */ 1926 if (pst 1927 && (textlow_not_set 1928 || (nlist.n_value < pst->textlow 1929 && (nlist.n_value 1930 != ANOFFSET (objfile->section_offsets, 1931 SECT_OFF_TEXT (objfile)))))) 1932 { 1933 pst->textlow = nlist.n_value; 1934 textlow_not_set = 0; 1935 } 1936 add_psymbol_to_list (namestring, p - namestring, 1937 VAR_DOMAIN, LOC_BLOCK, 1938 &objfile->global_psymbols, 1939 0, nlist.n_value, 1940 psymtab_language, objfile); 1941 continue; 1942 1943 /* Two things show up here (hopefully); static symbols of 1944 local scope (static used inside braces) or extensions 1945 of structure symbols. We can ignore both. */ 1946 case 'V': 1947 case '(': 1948 case '0': 1949 case '1': 1950 case '2': 1951 case '3': 1952 case '4': 1953 case '5': 1954 case '6': 1955 case '7': 1956 case '8': 1957 case '9': 1958 case '-': 1959 case '#': /* for symbol identification (used in live ranges) */ 1960 continue; 1961 1962 case ':': 1963 /* It is a C++ nested symbol. We don't need to record it 1964 (I don't think); if we try to look up foo::bar::baz, 1965 then symbols for the symtab containing foo should get 1966 read in, I think. */ 1967 /* Someone says sun cc puts out symbols like 1968 /foo/baz/maclib::/usr/local/bin/maclib, 1969 which would get here with a symbol type of ':'. */ 1970 continue; 1971 1972 default: 1973 /* Unexpected symbol descriptor. The second and subsequent stabs 1974 of a continued stab can show up here. The question is 1975 whether they ever can mimic a normal stab--it would be 1976 nice if not, since we certainly don't want to spend the 1977 time searching to the end of every string looking for 1978 a backslash. */ 1979 1980 complaint (&symfile_complaints, "unknown symbol descriptor `%c'", 1981 p[1]); 1982 1983 /* Ignore it; perhaps it is an extension that we don't 1984 know about. */ 1985 continue; 1986 } 1987 1988 case N_EXCL: 1989 1990 namestring = set_namestring (objfile, nlist); 1991 1992 /* Find the corresponding bincl and mark that psymtab on the 1993 psymtab dependency list */ 1994 { 1995 struct partial_symtab *needed_pst = 1996 find_corresponding_bincl_psymtab (namestring, nlist.n_value); 1997 1998 /* If this include file was defined earlier in this file, 1999 leave it alone. */ 2000 if (needed_pst == pst) 2001 continue; 2002 2003 if (needed_pst) 2004 { 2005 int i; 2006 int found = 0; 2007 2008 for (i = 0; i < dependencies_used; i++) 2009 if (dependency_list[i] == needed_pst) 2010 { 2011 found = 1; 2012 break; 2013 } 2014 2015 /* If it's already in the list, skip the rest. */ 2016 if (found) 2017 continue; 2018 2019 dependency_list[dependencies_used++] = needed_pst; 2020 if (dependencies_used >= dependencies_allocated) 2021 { 2022 struct partial_symtab **orig = dependency_list; 2023 dependency_list = 2024 (struct partial_symtab **) 2025 alloca ((dependencies_allocated *= 2) 2026 * sizeof (struct partial_symtab *)); 2027 memcpy (dependency_list, orig, 2028 (dependencies_used 2029 * sizeof (struct partial_symtab *))); 2030#ifdef DEBUG_INFO 2031 fprintf_unfiltered (gdb_stderr, "Had to reallocate dependency list.\n"); 2032 fprintf_unfiltered (gdb_stderr, "New dependencies allocated: %d\n", 2033 dependencies_allocated); 2034#endif 2035 } 2036 } 2037 } 2038 continue; 2039 2040 case N_ENDM: 2041#ifdef SOFUN_ADDRESS_MAYBE_MISSING 2042 /* Solaris 2 end of module, finish current partial symbol table. 2043 end_psymtab will set pst->texthigh to the proper value, which 2044 is necessary if a module compiled without debugging info 2045 follows this module. */ 2046 if (pst) 2047 { 2048 end_psymtab (pst, psymtab_include_list, includes_used, 2049 symnum * symbol_size, 2050 (CORE_ADDR) 0, 2051 dependency_list, dependencies_used, textlow_not_set); 2052 pst = (struct partial_symtab *) 0; 2053 includes_used = 0; 2054 dependencies_used = 0; 2055 } 2056#endif 2057 continue; 2058 2059 case N_RBRAC: 2060#ifdef HANDLE_RBRAC 2061 HANDLE_RBRAC (nlist.n_value); 2062 continue; 2063#endif 2064 case N_EINCL: 2065 case N_DSLINE: 2066 case N_BSLINE: 2067 case N_SSYM: /* Claim: Structure or union element. 2068 Hopefully, I can ignore this. */ 2069 case N_ENTRY: /* Alternate entry point; can ignore. */ 2070 case N_MAIN: /* Can definitely ignore this. */ 2071 case N_CATCH: /* These are GNU C++ extensions */ 2072 case N_EHDECL: /* that can safely be ignored here. */ 2073 case N_LENG: 2074 case N_BCOMM: 2075 case N_ECOMM: 2076 case N_ECOML: 2077 case N_FNAME: 2078 case N_SLINE: 2079 case N_RSYM: 2080 case N_PSYM: 2081 case N_LBRAC: 2082 case N_NSYMS: /* Ultrix 4.0: symbol count */ 2083 case N_DEFD: /* GNU Modula-2 */ 2084 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ 2085 2086 case N_OBJ: /* useless types from Solaris */ 2087 case N_OPT: 2088 case N_PATCH: 2089 /* These symbols aren't interesting; don't worry about them */ 2090 2091 continue; 2092 2093 default: 2094 /* If we haven't found it yet, ignore it. It's probably some 2095 new type we don't know about yet. */ 2096 unknown_symtype_complaint (local_hex_string (nlist.n_type)); 2097 continue; 2098 } 2099 } 2100 2101 /* If there's stuff to be cleaned up, clean it up. */ 2102 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */ 2103 /*FIXME, does this have a bug at start address 0? */ 2104 && last_o_file_start 2105 && objfile->ei.entry_point < nlist.n_value 2106 && objfile->ei.entry_point >= last_o_file_start) 2107 { 2108 objfile->ei.deprecated_entry_file_lowpc = last_o_file_start; 2109 objfile->ei.deprecated_entry_file_highpc = nlist.n_value; 2110 } 2111 2112 if (pst) 2113 { 2114 /* Don't set pst->texthigh lower than it already is. */ 2115 CORE_ADDR text_end = 2116 (lowest_text_address == (CORE_ADDR) -1 2117 ? (text_addr + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile))) 2118 : lowest_text_address) 2119 + text_size; 2120 2121 end_psymtab (pst, psymtab_include_list, includes_used, 2122 symnum * symbol_size, 2123 text_end > pst->texthigh ? text_end : pst->texthigh, 2124 dependency_list, dependencies_used, textlow_not_set); 2125 } 2126 2127 do_cleanups (back_to); 2128} 2129 2130/* Allocate and partially fill a partial symtab. It will be 2131 completely filled at the end of the symbol list. 2132 2133 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR 2134 is the address relative to which its symbols are (incremental) or 0 2135 (normal). */ 2136 2137 2138static struct partial_symtab * 2139start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow, 2140 int ldsymoff, struct partial_symbol **global_syms, 2141 struct partial_symbol **static_syms) 2142{ 2143 struct partial_symtab *result = 2144 start_psymtab_common (objfile, objfile->section_offsets, 2145 filename, textlow, global_syms, static_syms); 2146 2147 result->read_symtab_private = (char *) 2148 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc)); 2149 LDSYMOFF (result) = ldsymoff; 2150 result->read_symtab = dbx_psymtab_to_symtab; 2151 SYMBOL_SIZE (result) = symbol_size; 2152 SYMBOL_OFFSET (result) = symbol_table_offset; 2153 STRING_OFFSET (result) = string_table_offset; 2154 FILE_STRING_OFFSET (result) = file_string_table_offset; 2155 2156 /* If we're handling an ELF file, drag some section-relocation info 2157 for this source file out of the ELF symbol table, to compensate for 2158 Sun brain death. This replaces the section_offsets in this psymtab, 2159 if successful. */ 2160 elfstab_offset_sections (objfile, result); 2161 2162 /* Deduce the source language from the filename for this psymtab. */ 2163 psymtab_language = deduce_language_from_filename (filename); 2164 2165 return result; 2166} 2167 2168/* Close off the current usage of PST. 2169 Returns PST or NULL if the partial symtab was empty and thrown away. 2170 2171 FIXME: List variables and peculiarities of same. */ 2172 2173struct partial_symtab * 2174end_psymtab (struct partial_symtab *pst, char **include_list, int num_includes, 2175 int capping_symbol_offset, CORE_ADDR capping_text, 2176 struct partial_symtab **dependency_list, int number_dependencies, 2177 int textlow_not_set) 2178{ 2179 int i; 2180 struct objfile *objfile = pst->objfile; 2181 2182 if (capping_symbol_offset != -1) 2183 LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst); 2184 pst->texthigh = capping_text; 2185 2186#ifdef SOFUN_ADDRESS_MAYBE_MISSING 2187 /* Under Solaris, the N_SO symbols always have a value of 0, 2188 instead of the usual address of the .o file. Therefore, 2189 we have to do some tricks to fill in texthigh and textlow. 2190 The first trick is: if we see a static 2191 or global function, and the textlow for the current pst 2192 is not set (ie: textlow_not_set), then we use that function's 2193 address for the textlow of the pst. */ 2194 2195 /* Now, to fill in texthigh, we remember the last function seen 2196 in the .o file. Also, there's a hack in 2197 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field 2198 to here via the misc_info field. Therefore, we can fill in 2199 a reliable texthigh by taking the address plus size of the 2200 last function in the file. */ 2201 2202 if (pst->texthigh == 0 && last_function_name) 2203 { 2204 char *p; 2205 int n; 2206 struct minimal_symbol *minsym; 2207 2208 p = strchr (last_function_name, ':'); 2209 if (p == NULL) 2210 p = last_function_name; 2211 n = p - last_function_name; 2212 p = alloca (n + 2); 2213 strncpy (p, last_function_name, n); 2214 p[n] = 0; 2215 2216 minsym = lookup_minimal_symbol (p, pst->filename, objfile); 2217 if (minsym == NULL) 2218 { 2219 /* Sun Fortran appends an underscore to the minimal symbol name, 2220 try again with an appended underscore if the minimal symbol 2221 was not found. */ 2222 p[n] = '_'; 2223 p[n + 1] = 0; 2224 minsym = lookup_minimal_symbol (p, pst->filename, objfile); 2225 } 2226 2227 if (minsym) 2228 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym); 2229 2230 last_function_name = NULL; 2231 } 2232 2233 /* this test will be true if the last .o file is only data */ 2234 if (textlow_not_set) 2235 pst->textlow = pst->texthigh; 2236 else 2237 { 2238 struct partial_symtab *p1; 2239 2240 /* If we know our own starting text address, then walk through all other 2241 psymtabs for this objfile, and if any didn't know their ending text 2242 address, set it to our starting address. Take care to not set our 2243 own ending address to our starting address, nor to set addresses on 2244 `dependency' files that have both textlow and texthigh zero. */ 2245 2246 ALL_OBJFILE_PSYMTABS (objfile, p1) 2247 { 2248 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst) 2249 { 2250 p1->texthigh = pst->textlow; 2251 /* if this file has only data, then make textlow match texthigh */ 2252 if (p1->textlow == 0) 2253 p1->textlow = p1->texthigh; 2254 } 2255 } 2256 } 2257 2258 /* End of kludge for patching Solaris textlow and texthigh. */ 2259#endif /* SOFUN_ADDRESS_MAYBE_MISSING. */ 2260 2261 pst->n_global_syms = 2262 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset); 2263 pst->n_static_syms = 2264 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset); 2265 2266 pst->number_of_dependencies = number_dependencies; 2267 if (number_dependencies) 2268 { 2269 pst->dependencies = (struct partial_symtab **) 2270 obstack_alloc (&objfile->objfile_obstack, 2271 number_dependencies * sizeof (struct partial_symtab *)); 2272 memcpy (pst->dependencies, dependency_list, 2273 number_dependencies * sizeof (struct partial_symtab *)); 2274 } 2275 else 2276 pst->dependencies = 0; 2277 2278 for (i = 0; i < num_includes; i++) 2279 { 2280 struct partial_symtab *subpst = 2281 allocate_psymtab (include_list[i], objfile); 2282 2283 /* Copy the sesction_offsets array from the main psymtab. */ 2284 subpst->section_offsets = pst->section_offsets; 2285 subpst->read_symtab_private = 2286 (char *) obstack_alloc (&objfile->objfile_obstack, 2287 sizeof (struct symloc)); 2288 LDSYMOFF (subpst) = 2289 LDSYMLEN (subpst) = 2290 subpst->textlow = 2291 subpst->texthigh = 0; 2292 2293 /* We could save slight bits of space by only making one of these, 2294 shared by the entire set of include files. FIXME-someday. */ 2295 subpst->dependencies = (struct partial_symtab **) 2296 obstack_alloc (&objfile->objfile_obstack, 2297 sizeof (struct partial_symtab *)); 2298 subpst->dependencies[0] = pst; 2299 subpst->number_of_dependencies = 1; 2300 2301 subpst->globals_offset = 2302 subpst->n_global_syms = 2303 subpst->statics_offset = 2304 subpst->n_static_syms = 0; 2305 2306 subpst->readin = 0; 2307 subpst->symtab = 0; 2308 subpst->read_symtab = pst->read_symtab; 2309 } 2310 2311 sort_pst_symbols (pst); 2312 2313 /* If there is already a psymtab or symtab for a file of this name, remove it. 2314 (If there is a symtab, more drastic things also happen.) 2315 This happens in VxWorks. */ 2316 free_named_symtabs (pst->filename); 2317 2318 if (num_includes == 0 2319 && number_dependencies == 0 2320 && pst->n_global_syms == 0 2321 && pst->n_static_syms == 0 2322 && has_line_numbers == 0) 2323 { 2324 /* Throw away this psymtab, it's empty. We can't deallocate it, since 2325 it is on the obstack, but we can forget to chain it on the list. */ 2326 /* Empty psymtabs happen as a result of header files which don't have 2327 any symbols in them. There can be a lot of them. But this check 2328 is wrong, in that a psymtab with N_SLINE entries but nothing else 2329 is not empty, but we don't realize that. Fixing that without slowing 2330 things down might be tricky. */ 2331 2332 discard_psymtab (pst); 2333 2334 /* Indicate that psymtab was thrown away. */ 2335 pst = (struct partial_symtab *) NULL; 2336 } 2337 return pst; 2338} 2339 2340static void 2341dbx_psymtab_to_symtab_1 (struct partial_symtab *pst) 2342{ 2343 struct cleanup *old_chain; 2344 int i; 2345 2346 if (!pst) 2347 return; 2348 2349 if (pst->readin) 2350 { 2351 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n", 2352 pst->filename); 2353 return; 2354 } 2355 2356 /* Read in all partial symtabs on which this one is dependent */ 2357 for (i = 0; i < pst->number_of_dependencies; i++) 2358 if (!pst->dependencies[i]->readin) 2359 { 2360 /* Inform about additional files that need to be read in. */ 2361 if (info_verbose) 2362 { 2363 fputs_filtered (" ", gdb_stdout); 2364 wrap_here (""); 2365 fputs_filtered ("and ", gdb_stdout); 2366 wrap_here (""); 2367 printf_filtered ("%s...", pst->dependencies[i]->filename); 2368 wrap_here (""); /* Flush output */ 2369 gdb_flush (gdb_stdout); 2370 } 2371 dbx_psymtab_to_symtab_1 (pst->dependencies[i]); 2372 } 2373 2374 if (LDSYMLEN (pst)) /* Otherwise it's a dummy */ 2375 { 2376 /* Init stuff necessary for reading in symbols */ 2377 stabsread_init (); 2378 buildsym_init (); 2379 old_chain = make_cleanup (really_free_pendings, 0); 2380 file_string_table_offset = FILE_STRING_OFFSET (pst); 2381 symbol_size = SYMBOL_SIZE (pst); 2382 2383 /* Read in this file's symbols */ 2384 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET); 2385 read_ofile_symtab (pst); 2386 2387 do_cleanups (old_chain); 2388 } 2389 2390 pst->readin = 1; 2391} 2392 2393/* Read in all of the symbols for a given psymtab for real. 2394 Be verbose about it if the user wants that. */ 2395 2396static void 2397dbx_psymtab_to_symtab (struct partial_symtab *pst) 2398{ 2399 bfd *sym_bfd; 2400 struct cleanup *back_to = NULL; 2401 2402 if (!pst) 2403 return; 2404 2405 if (pst->readin) 2406 { 2407 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n", 2408 pst->filename); 2409 return; 2410 } 2411 2412 if (LDSYMLEN (pst) || pst->number_of_dependencies) 2413 { 2414 /* Print the message now, before reading the string table, 2415 to avoid disconcerting pauses. */ 2416 if (info_verbose) 2417 { 2418 printf_filtered ("Reading in symbols for %s...", pst->filename); 2419 gdb_flush (gdb_stdout); 2420 } 2421 2422 sym_bfd = pst->objfile->obfd; 2423 2424 next_symbol_text_func = dbx_next_symbol_text; 2425 2426 if (DBX_STAB_SECTION (pst->objfile)) 2427 { 2428 stabs_data 2429 = symfile_relocate_debug_section (pst->objfile->obfd, 2430 DBX_STAB_SECTION (pst->objfile), 2431 NULL); 2432 if (stabs_data) 2433 back_to = make_cleanup (free_current_contents, (void *) &stabs_data); 2434 } 2435 2436 dbx_psymtab_to_symtab_1 (pst); 2437 2438 if (back_to) 2439 do_cleanups (back_to); 2440 2441 /* Match with global symbols. This only needs to be done once, 2442 after all of the symtabs and dependencies have been read in. */ 2443 scan_file_globals (pst->objfile); 2444 2445 /* Finish up the debug error message. */ 2446 if (info_verbose) 2447 printf_filtered ("done.\n"); 2448 } 2449} 2450 2451/* Read in a defined section of a specific object file's symbols. */ 2452 2453static void 2454read_ofile_symtab (struct partial_symtab *pst) 2455{ 2456 char *namestring; 2457 struct external_nlist *bufp; 2458 struct internal_nlist nlist; 2459 unsigned char type; 2460 unsigned max_symnum; 2461 bfd *abfd; 2462 struct objfile *objfile; 2463 int sym_offset; /* Offset to start of symbols to read */ 2464 int sym_size; /* Size of symbols to read */ 2465 CORE_ADDR text_offset; /* Start of text segment for symbols */ 2466 int text_size; /* Size of text segment for symbols */ 2467 struct section_offsets *section_offsets; 2468 2469 objfile = pst->objfile; 2470 sym_offset = LDSYMOFF (pst); 2471 sym_size = LDSYMLEN (pst); 2472 text_offset = pst->textlow; 2473 text_size = pst->texthigh - pst->textlow; 2474 /* This cannot be simply objfile->section_offsets because of 2475 elfstab_offset_sections() which initializes the psymtab section 2476 offsets information in a special way, and that is different from 2477 objfile->section_offsets. */ 2478 section_offsets = pst->section_offsets; 2479 2480 current_objfile = objfile; 2481 subfile_stack = NULL; 2482 2483 stringtab_global = DBX_STRINGTAB (objfile); 2484 last_source_file = NULL; 2485 2486 abfd = objfile->obfd; 2487 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */ 2488 symbuf_end = symbuf_idx = 0; 2489 symbuf_read = 0; 2490 symbuf_left = sym_offset + sym_size; 2491 2492 /* It is necessary to actually read one symbol *before* the start 2493 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL 2494 occurs before the N_SO symbol. 2495 2496 Detecting this in read_dbx_symtab 2497 would slow down initial readin, so we look for it here instead. */ 2498 if (!processing_acc_compilation && sym_offset >= (int) symbol_size) 2499 { 2500 stabs_seek (sym_offset - symbol_size); 2501 fill_symbuf (abfd); 2502 bufp = &symbuf[symbuf_idx++]; 2503 INTERNALIZE_SYMBOL (nlist, bufp, abfd); 2504 OBJSTAT (objfile, n_stabs++); 2505 2506 namestring = set_namestring (objfile, nlist); 2507 2508 processing_gcc_compilation = 0; 2509 if (nlist.n_type == N_TEXT) 2510 { 2511 const char *tempstring = namestring; 2512 2513 if (DEPRECATED_STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL)) 2514 processing_gcc_compilation = 1; 2515 else if (DEPRECATED_STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL)) 2516 processing_gcc_compilation = 2; 2517 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd)) 2518 ++tempstring; 2519 if (DEPRECATED_STREQN (tempstring, "__gnu_compiled", 14)) 2520 processing_gcc_compilation = 2; 2521 } 2522 2523 /* Try to select a C++ demangling based on the compilation unit 2524 producer. */ 2525 2526#if 0 2527 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't 2528 know whether it will use the old style or v3 mangling. */ 2529 if (processing_gcc_compilation) 2530 { 2531 if (AUTO_DEMANGLING) 2532 { 2533 set_demangling_style (GNU_DEMANGLING_STYLE_STRING); 2534 } 2535 } 2536#endif 2537 } 2538 else 2539 { 2540 /* The N_SO starting this symtab is the first symbol, so we 2541 better not check the symbol before it. I'm not this can 2542 happen, but it doesn't hurt to check for it. */ 2543 stabs_seek (sym_offset); 2544 processing_gcc_compilation = 0; 2545 } 2546 2547 if (symbuf_idx == symbuf_end) 2548 fill_symbuf (abfd); 2549 bufp = &symbuf[symbuf_idx]; 2550 if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO) 2551 error ("First symbol in segment of executable not a source symbol"); 2552 2553 max_symnum = sym_size / symbol_size; 2554 2555 for (symnum = 0; 2556 symnum < max_symnum; 2557 symnum++) 2558 { 2559 QUIT; /* Allow this to be interruptable */ 2560 if (symbuf_idx == symbuf_end) 2561 fill_symbuf (abfd); 2562 bufp = &symbuf[symbuf_idx++]; 2563 INTERNALIZE_SYMBOL (nlist, bufp, abfd); 2564 OBJSTAT (objfile, n_stabs++); 2565 2566 type = bfd_h_get_8 (abfd, bufp->e_type); 2567 2568 namestring = set_namestring (objfile, nlist); 2569 2570 if (type & N_STAB) 2571 { 2572 process_one_symbol (type, nlist.n_desc, nlist.n_value, 2573 namestring, section_offsets, objfile); 2574 } 2575 /* We skip checking for a new .o or -l file; that should never 2576 happen in this routine. */ 2577 else if (type == N_TEXT) 2578 { 2579 /* I don't think this code will ever be executed, because 2580 the GCC_COMPILED_FLAG_SYMBOL usually is right before 2581 the N_SO symbol which starts this source file. 2582 However, there is no reason not to accept 2583 the GCC_COMPILED_FLAG_SYMBOL anywhere. */ 2584 2585 if (DEPRECATED_STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL)) 2586 processing_gcc_compilation = 1; 2587 else if (DEPRECATED_STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL)) 2588 processing_gcc_compilation = 2; 2589 2590#if 0 2591 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't 2592 know whether it will use the old style or v3 mangling. */ 2593 if (AUTO_DEMANGLING) 2594 { 2595 set_demangling_style (GNU_DEMANGLING_STYLE_STRING); 2596 } 2597#endif 2598 } 2599 else if (type & N_EXT || type == (unsigned char) N_TEXT 2600 || type == (unsigned char) N_NBTEXT 2601 ) 2602 { 2603 /* Global symbol: see if we came across a dbx defintion for 2604 a corresponding symbol. If so, store the value. Remove 2605 syms from the chain when their values are stored, but 2606 search the whole chain, as there may be several syms from 2607 different files with the same name. */ 2608 /* This is probably not true. Since the files will be read 2609 in one at a time, each reference to a global symbol will 2610 be satisfied in each file as it appears. So we skip this 2611 section. */ 2612 ; 2613 } 2614 } 2615 2616 current_objfile = NULL; 2617 2618 /* In a Solaris elf file, this variable, which comes from the 2619 value of the N_SO symbol, will still be 0. Luckily, text_offset, 2620 which comes from pst->textlow is correct. */ 2621 if (last_source_start_addr == 0) 2622 last_source_start_addr = text_offset; 2623 2624 /* In reordered executables last_source_start_addr may not be the 2625 lower bound for this symtab, instead use text_offset which comes 2626 from pst->textlow which is correct. */ 2627 if (last_source_start_addr > text_offset) 2628 last_source_start_addr = text_offset; 2629 2630 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile)); 2631 2632 end_stabs (); 2633} 2634 2635 2636/* This handles a single symbol from the symbol-file, building symbols 2637 into a GDB symtab. It takes these arguments and an implicit argument. 2638 2639 TYPE is the type field of the ".stab" symbol entry. 2640 DESC is the desc field of the ".stab" entry. 2641 VALU is the value field of the ".stab" entry. 2642 NAME is the symbol name, in our address space. 2643 SECTION_OFFSETS is a set of amounts by which the sections of this object 2644 file were relocated when it was loaded into memory. 2645 Note that these section_offsets are not the 2646 objfile->section_offsets but the pst->section_offsets. 2647 All symbols that refer 2648 to memory locations need to be offset by these amounts. 2649 OBJFILE is the object file from which we are reading symbols. 2650 It is used in end_symtab. */ 2651 2652void 2653process_one_symbol (int type, int desc, CORE_ADDR valu, char *name, 2654 struct section_offsets *section_offsets, 2655 struct objfile *objfile) 2656{ 2657#ifdef SUN_FIXED_LBRAC_BUG 2658 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need 2659 to correct the address of N_LBRAC's. If it is not defined, then 2660 we never need to correct the addresses. */ 2661 2662 /* This records the last pc address we've seen. We depend on there being 2663 an SLINE or FUN or SO before the first LBRAC, since the variable does 2664 not get reset in between reads of different symbol files. */ 2665 static CORE_ADDR last_pc_address; 2666#endif 2667 2668 struct context_stack *new; 2669 /* This remembers the address of the start of a function. It is used 2670 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are 2671 relative to the current function's start address. On systems 2672 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is 2673 used to relocate these symbol types rather than SECTION_OFFSETS. */ 2674 static CORE_ADDR function_start_offset; 2675 2676 /* This holds the address of the start of a function, without the system 2677 peculiarities of function_start_offset. */ 2678 static CORE_ADDR last_function_start; 2679 2680 /* If this is nonzero, we've seen an N_SLINE since the start of the 2681 current function. We use this to tell us to move the first sline 2682 to the beginning of the function regardless of what its given 2683 value is. */ 2684 static int sline_found_in_function = 1; 2685 2686 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source 2687 file. Used to detect the SunPRO solaris compiler. */ 2688 static int n_opt_found; 2689 2690 /* The stab type used for the definition of the last function. 2691 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */ 2692 static int function_stab_type = 0; 2693 2694 if (!block_address_function_relative) 2695 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the 2696 function start address, so just use the text offset. */ 2697 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 2698 2699 /* Something is wrong if we see real data before 2700 seeing a source file name. */ 2701 2702 if (last_source_file == NULL && type != (unsigned char) N_SO) 2703 { 2704 /* Ignore any symbols which appear before an N_SO symbol. 2705 Currently no one puts symbols there, but we should deal 2706 gracefully with the case. A complain()t might be in order, 2707 but this should not be an error (). */ 2708 return; 2709 } 2710 2711 switch (type) 2712 { 2713 case N_FUN: 2714 case N_FNAME: 2715 2716 if (*name == '\000') 2717 { 2718 /* This N_FUN marks the end of a function. This closes off the 2719 current block. */ 2720 2721 if (context_stack_depth <= 0) 2722 { 2723 lbrac_mismatch_complaint (symnum); 2724 break; 2725 } 2726 2727 /* The following check is added before recording line 0 at 2728 end of function so as to handle hand-generated stabs 2729 which may have an N_FUN stabs at the end of the function, but 2730 no N_SLINE stabs. */ 2731 if (sline_found_in_function) 2732 record_line (current_subfile, 0, last_function_start + valu); 2733 2734 within_function = 0; 2735 new = pop_context (); 2736 2737 /* Make a block for the local symbols within. */ 2738 finish_block (new->name, &local_symbols, new->old_blocks, 2739 new->start_addr, new->start_addr + valu, 2740 objfile); 2741 2742 /* May be switching to an assembler file which may not be using 2743 block relative stabs, so reset the offset. */ 2744 if (block_address_function_relative) 2745 function_start_offset = 0; 2746 2747 break; 2748 } 2749 2750 sline_found_in_function = 0; 2751 2752 /* Relocate for dynamic loading */ 2753 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 2754 valu = SMASH_TEXT_ADDRESS (valu); 2755 last_function_start = valu; 2756 2757 goto define_a_symbol; 2758 2759 case N_LBRAC: 2760 /* This "symbol" just indicates the start of an inner lexical 2761 context within a function. */ 2762 2763 /* Ignore extra outermost context from SunPRO cc and acc. */ 2764 if (n_opt_found && desc == 1) 2765 break; 2766 2767 if (block_address_function_relative) 2768 /* Relocate for Sun ELF acc fn-relative syms. */ 2769 valu += function_start_offset; 2770 else 2771 /* On most machines, the block addresses are relative to the 2772 N_SO, the linker did not relocate them (sigh). */ 2773 valu += last_source_start_addr; 2774 2775#ifdef SUN_FIXED_LBRAC_BUG 2776 if (!SUN_FIXED_LBRAC_BUG && valu < last_pc_address) 2777 { 2778 /* Patch current LBRAC pc value to match last handy pc value */ 2779 complaint (&symfile_complaints, "bad block start address patched"); 2780 valu = last_pc_address; 2781 } 2782#endif 2783 new = push_context (desc, valu); 2784 break; 2785 2786 case N_RBRAC: 2787 /* This "symbol" just indicates the end of an inner lexical 2788 context that was started with N_LBRAC. */ 2789 2790 /* Ignore extra outermost context from SunPRO cc and acc. */ 2791 if (n_opt_found && desc == 1) 2792 break; 2793 2794 if (block_address_function_relative) 2795 /* Relocate for Sun ELF acc fn-relative syms. */ 2796 valu += function_start_offset; 2797 else 2798 /* On most machines, the block addresses are relative to the 2799 N_SO, the linker did not relocate them (sigh). */ 2800 valu += last_source_start_addr; 2801 2802 if (context_stack_depth <= 0) 2803 { 2804 lbrac_mismatch_complaint (symnum); 2805 break; 2806 } 2807 2808 new = pop_context (); 2809 if (desc != new->depth) 2810 lbrac_mismatch_complaint (symnum); 2811 2812 /* Some compilers put the variable decls inside of an 2813 LBRAC/RBRAC block. This macro should be nonzero if this 2814 is true. DESC is N_DESC from the N_RBRAC symbol. 2815 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL 2816 or the GCC2_COMPILED_SYMBOL. */ 2817#if !defined (VARIABLES_INSIDE_BLOCK) 2818#define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0 2819#endif 2820 2821 /* Can only use new->locals as local symbols here if we're in 2822 gcc or on a machine that puts them before the lbrack. */ 2823 if (!VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation)) 2824 { 2825 if (local_symbols != NULL) 2826 { 2827 /* GCC development snapshots from March to December of 2828 2000 would output N_LSYM entries after N_LBRAC 2829 entries. As a consequence, these symbols are simply 2830 discarded. Complain if this is the case. Note that 2831 there are some compilers which legitimately put local 2832 symbols within an LBRAC/RBRAC block; this complaint 2833 might also help sort out problems in which 2834 VARIABLES_INSIDE_BLOCK is incorrectly defined. */ 2835 complaint (&symfile_complaints, 2836 "misplaced N_LBRAC entry; discarding local symbols which have no enclosing block"); 2837 } 2838 local_symbols = new->locals; 2839 } 2840 2841 if (context_stack_depth 2842 > !VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation)) 2843 { 2844 /* This is not the outermost LBRAC...RBRAC pair in the function, 2845 its local symbols preceded it, and are the ones just recovered 2846 from the context stack. Define the block for them (but don't 2847 bother if the block contains no symbols. Should we complain 2848 on blocks without symbols? I can't think of any useful purpose 2849 for them). */ 2850 if (local_symbols != NULL) 2851 { 2852 /* Muzzle a compiler bug that makes end < start. (which 2853 compilers? Is this ever harmful?). */ 2854 if (new->start_addr > valu) 2855 { 2856 complaint (&symfile_complaints, 2857 "block start larger than block end"); 2858 new->start_addr = valu; 2859 } 2860 /* Make a block for the local symbols within. */ 2861 finish_block (0, &local_symbols, new->old_blocks, 2862 new->start_addr, valu, objfile); 2863 } 2864 } 2865 else 2866 { 2867 /* This is the outermost LBRAC...RBRAC pair. There is no 2868 need to do anything; leave the symbols that preceded it 2869 to be attached to the function's own block. We need to 2870 indicate that we just moved outside of the function. */ 2871 within_function = 0; 2872 } 2873 2874 if (VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation)) 2875 /* Now pop locals of block just finished. */ 2876 local_symbols = new->locals; 2877 break; 2878 2879 case N_FN: 2880 case N_FN_SEQ: 2881 /* This kind of symbol indicates the start of an object file. */ 2882 /* Relocate for dynamic loading */ 2883 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 2884 break; 2885 2886 case N_SO: 2887 /* This type of symbol indicates the start of data 2888 for one source file. 2889 Finish the symbol table of the previous source file 2890 (if any) and start accumulating a new symbol table. */ 2891 /* Relocate for dynamic loading */ 2892 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 2893 2894 n_opt_found = 0; 2895 2896#ifdef SUN_FIXED_LBRAC_BUG 2897 last_pc_address = valu; /* Save for SunOS bug circumcision */ 2898#endif 2899 2900#ifdef PCC_SOL_BROKEN 2901 /* pcc bug, occasionally puts out SO for SOL. */ 2902 if (context_stack_depth > 0) 2903 { 2904 start_subfile (name, NULL); 2905 break; 2906 } 2907#endif 2908 if (last_source_file) 2909 { 2910 /* Check if previous symbol was also an N_SO (with some 2911 sanity checks). If so, that one was actually the directory 2912 name, and the current one is the real file name. 2913 Patch things up. */ 2914 if (previous_stab_code == (unsigned char) N_SO) 2915 { 2916 patch_subfile_names (current_subfile, name); 2917 break; /* Ignore repeated SOs */ 2918 } 2919 end_symtab (valu, objfile, SECT_OFF_TEXT (objfile)); 2920 end_stabs (); 2921 } 2922 2923 /* Null name means this just marks the end of text for this .o file. 2924 Don't start a new symtab in this case. */ 2925 if (*name == '\000') 2926 break; 2927 2928 if (block_address_function_relative) 2929 function_start_offset = 0; 2930 2931 start_stabs (); 2932 start_symtab (name, NULL, valu); 2933 record_debugformat ("stabs"); 2934 break; 2935 2936 case N_SOL: 2937 /* This type of symbol indicates the start of data for 2938 a sub-source-file, one whose contents were copied or 2939 included in the compilation of the main source file 2940 (whose name was given in the N_SO symbol.) */ 2941 /* Relocate for dynamic loading */ 2942 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 2943 start_subfile (name, current_subfile->dirname); 2944 break; 2945 2946 case N_BINCL: 2947 push_subfile (); 2948 add_new_header_file (name, valu); 2949 start_subfile (name, current_subfile->dirname); 2950 break; 2951 2952 case N_EINCL: 2953 start_subfile (pop_subfile (), current_subfile->dirname); 2954 break; 2955 2956 case N_EXCL: 2957 add_old_header_file (name, valu); 2958 break; 2959 2960 case N_SLINE: 2961 /* This type of "symbol" really just records 2962 one line-number -- core-address correspondence. 2963 Enter it in the line list for this symbol table. */ 2964 2965 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */ 2966 valu += function_start_offset; 2967 2968#ifdef SUN_FIXED_LBRAC_BUG 2969 last_pc_address = valu; /* Save for SunOS bug circumcision */ 2970#endif 2971 /* If this is the first SLINE note in the function, record it at 2972 the start of the function instead of at the listed location. */ 2973 if (within_function && sline_found_in_function == 0) 2974 { 2975 record_line (current_subfile, desc, last_function_start); 2976 sline_found_in_function = 1; 2977 } 2978 else 2979 record_line (current_subfile, desc, valu); 2980 break; 2981 2982 case N_BCOMM: 2983 common_block_start (name, objfile); 2984 break; 2985 2986 case N_ECOMM: 2987 common_block_end (objfile); 2988 break; 2989 2990 /* The following symbol types need to have the appropriate offset added 2991 to their value; then we process symbol definitions in the name. */ 2992 2993 case N_STSYM: /* Static symbol in data seg */ 2994 case N_LCSYM: /* Static symbol in BSS seg */ 2995 case N_ROSYM: /* Static symbol in Read-only data seg */ 2996 /* HORRID HACK DEPT. However, it's Sun's furgin' fault. 2997 Solaris2's stabs-in-elf makes *most* symbols relative 2998 but leaves a few absolute (at least for Solaris 2.1 and version 2999 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence. 3000 .stab "foo:S...",N_STSYM is absolute (ld relocates it) 3001 .stab "foo:V...",N_STSYM is relative (section base subtracted). 3002 This leaves us no choice but to search for the 'S' or 'V'... 3003 (or pass the whole section_offsets stuff down ONE MORE function 3004 call level, which we really don't want to do). */ 3005 { 3006 char *p; 3007 3008 /* .o files and NLMs have non-zero text seg offsets, but don't need 3009 their static syms offset in this fashion. XXX - This is really a 3010 crock that should be fixed in the solib handling code so that I 3011 don't have to work around it here. */ 3012 3013 if (!symfile_relocatable) 3014 { 3015 p = strchr (name, ':'); 3016 if (p != 0 && p[1] == 'S') 3017 { 3018 /* The linker relocated it. We don't want to add an 3019 elfstab_offset_sections-type offset, but we *do* want 3020 to add whatever solib.c passed to symbol_file_add as 3021 addr (this is known to affect SunOS4, and I suspect ELF 3022 too). Since elfstab_offset_sections currently does not 3023 muck with the text offset (there is no Ttext.text 3024 symbol), we can get addr from the text offset. If 3025 elfstab_offset_sections ever starts dealing with the 3026 text offset, and we still need to do this, we need to 3027 invent a SECT_OFF_ADDR_KLUDGE or something. */ 3028 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 3029 goto define_a_symbol; 3030 } 3031 } 3032 /* Since it's not the kludge case, re-dispatch to the right handler. */ 3033 switch (type) 3034 { 3035 case N_STSYM: 3036 goto case_N_STSYM; 3037 case N_LCSYM: 3038 goto case_N_LCSYM; 3039 case N_ROSYM: 3040 goto case_N_ROSYM; 3041 default: 3042 internal_error (__FILE__, __LINE__, "failed internal consistency check"); 3043 } 3044 } 3045 3046 case_N_STSYM: /* Static symbol in data seg */ 3047 case N_DSLINE: /* Source line number, data seg */ 3048 valu += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); 3049 goto define_a_symbol; 3050 3051 case_N_LCSYM: /* Static symbol in BSS seg */ 3052 case N_BSLINE: /* Source line number, bss seg */ 3053 /* N_BROWS: overlaps with N_BSLINE */ 3054 valu += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile)); 3055 goto define_a_symbol; 3056 3057 case_N_ROSYM: /* Static symbol in Read-only data seg */ 3058 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA (objfile)); 3059 goto define_a_symbol; 3060 3061 case N_ENTRY: /* Alternate entry point */ 3062 /* Relocate for dynamic loading */ 3063 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 3064 goto define_a_symbol; 3065 3066 /* The following symbol types we don't know how to process. Handle 3067 them in a "default" way, but complain to people who care. */ 3068 default: 3069 case N_CATCH: /* Exception handler catcher */ 3070 case N_EHDECL: /* Exception handler name */ 3071 case N_PC: /* Global symbol in Pascal */ 3072 case N_M2C: /* Modula-2 compilation unit */ 3073 /* N_MOD2: overlaps with N_EHDECL */ 3074 case N_SCOPE: /* Modula-2 scope information */ 3075 case N_ECOML: /* End common (local name) */ 3076 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */ 3077 case N_NBDATA: 3078 case N_NBBSS: 3079 case N_NBSTS: 3080 case N_NBLCS: 3081 unknown_symtype_complaint (local_hex_string (type)); 3082 /* FALLTHROUGH */ 3083 3084 /* The following symbol types don't need the address field relocated, 3085 since it is either unused, or is absolute. */ 3086 define_a_symbol: 3087 case N_GSYM: /* Global variable */ 3088 case N_NSYMS: /* Number of symbols (ultrix) */ 3089 case N_NOMAP: /* No map? (ultrix) */ 3090 case N_RSYM: /* Register variable */ 3091 case N_DEFD: /* Modula-2 GNU module dependency */ 3092 case N_SSYM: /* Struct or union element */ 3093 case N_LSYM: /* Local symbol in stack */ 3094 case N_PSYM: /* Parameter variable */ 3095 case N_LENG: /* Length of preceding symbol type */ 3096 if (name) 3097 { 3098 int deftype; 3099 char *colon_pos = strchr (name, ':'); 3100 if (colon_pos == NULL) 3101 deftype = '\0'; 3102 else 3103 deftype = colon_pos[1]; 3104 3105 switch (deftype) 3106 { 3107 case 'f': 3108 case 'F': 3109 function_stab_type = type; 3110 3111#ifdef SOFUN_ADDRESS_MAYBE_MISSING 3112 /* Deal with the SunPRO 3.0 compiler which omits the address 3113 from N_FUN symbols. */ 3114 if (type == N_FUN 3115 && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile))) 3116 { 3117 CORE_ADDR minsym_valu = 3118 find_stab_function_addr (name, last_source_file, objfile); 3119 3120 /* find_stab_function_addr will return 0 if the minimal 3121 symbol wasn't found. (Unfortunately, this might also 3122 be a valid address.) Anyway, if it *does* return 0, 3123 it is likely that the value was set correctly to begin 3124 with... */ 3125 if (minsym_valu != 0) 3126 valu = minsym_valu; 3127 } 3128#endif 3129 3130#ifdef SUN_FIXED_LBRAC_BUG 3131 /* The Sun acc compiler, under SunOS4, puts out 3132 functions with N_GSYM or N_STSYM. The problem is 3133 that the address of the symbol is no good (for N_GSYM 3134 it doesn't even attept an address; for N_STSYM it 3135 puts out an address but then it gets relocated 3136 relative to the data segment, not the text segment). 3137 Currently we can't fix this up later as we do for 3138 some types of symbol in scan_file_globals. 3139 Fortunately we do have a way of finding the address - 3140 we know that the value in last_pc_address is either 3141 the one we want (if we're dealing with the first 3142 function in an object file), or somewhere in the 3143 previous function. This means that we can use the 3144 minimal symbol table to get the address. */ 3145 3146 /* Starting with release 3.0, the Sun acc compiler, 3147 under SunOS4, puts out functions with N_FUN and a value 3148 of zero. This gets relocated to the start of the text 3149 segment of the module, which is no good either. 3150 Under SunOS4 we can deal with this as N_SLINE and N_SO 3151 entries contain valid absolute addresses. 3152 Release 3.0 acc also puts out N_OPT entries, which makes 3153 it possible to discern acc from cc or gcc. */ 3154 3155 if (type == N_GSYM || type == N_STSYM 3156 || (type == N_FUN 3157 && n_opt_found && !block_address_function_relative)) 3158 { 3159 struct minimal_symbol *m; 3160 int l = colon_pos - name; 3161 3162 m = lookup_minimal_symbol_by_pc (last_pc_address); 3163 if (m && strncmp (DEPRECATED_SYMBOL_NAME (m), name, l) == 0 3164 && DEPRECATED_SYMBOL_NAME (m)[l] == '\0') 3165 /* last_pc_address was in this function */ 3166 valu = SYMBOL_VALUE (m); 3167 else if (m && DEPRECATED_SYMBOL_NAME (m + 1) 3168 && strncmp (DEPRECATED_SYMBOL_NAME (m + 1), name, l) == 0 3169 && DEPRECATED_SYMBOL_NAME (m + 1)[l] == '\0') 3170 /* last_pc_address was in last function */ 3171 valu = SYMBOL_VALUE (m + 1); 3172 else 3173 /* Not found - use last_pc_address (for finish_block) */ 3174 valu = last_pc_address; 3175 } 3176 3177 last_pc_address = valu; /* Save for SunOS bug circumcision */ 3178#endif 3179 3180 if (block_address_function_relative) 3181 /* For Solaris 2.0 compilers, the block addresses and 3182 N_SLINE's are relative to the start of the 3183 function. On normal systems, and when using gcc on 3184 Solaris 2.0, these addresses are just absolute, or 3185 relative to the N_SO, depending on 3186 BLOCK_ADDRESS_ABSOLUTE. */ 3187 function_start_offset = valu; 3188 3189 within_function = 1; 3190 3191 if (context_stack_depth > 1) 3192 { 3193 complaint (&symfile_complaints, 3194 "unmatched N_LBRAC before symtab pos %d", symnum); 3195 break; 3196 } 3197 3198 if (context_stack_depth > 0) 3199 { 3200 new = pop_context (); 3201 /* Make a block for the local symbols within. */ 3202 finish_block (new->name, &local_symbols, new->old_blocks, 3203 new->start_addr, valu, objfile); 3204 } 3205 3206 new = push_context (0, valu); 3207 new->name = define_symbol (valu, name, desc, type, objfile); 3208 break; 3209 3210 default: 3211 define_symbol (valu, name, desc, type, objfile); 3212 break; 3213 } 3214 } 3215 break; 3216 3217 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it 3218 for a bunch of other flags, too. Someday we may parse their 3219 flags; for now we ignore theirs and hope they'll ignore ours. */ 3220 case N_OPT: /* Solaris 2: Compiler options */ 3221 if (name) 3222 { 3223 if (strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0) 3224 { 3225 processing_gcc_compilation = 2; 3226#if 0 /* Works, but is experimental. -fnf */ 3227 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't 3228 know whether it will use the old style or v3 mangling. */ 3229 if (AUTO_DEMANGLING) 3230 { 3231 set_demangling_style (GNU_DEMANGLING_STYLE_STRING); 3232 } 3233#endif 3234 } 3235 else 3236 n_opt_found = 1; 3237 } 3238 break; 3239 3240 case N_MAIN: /* Name of main routine. */ 3241 /* FIXME: If one has a symbol file with N_MAIN and then replaces 3242 it with a symbol file with "main" and without N_MAIN. I'm 3243 not sure exactly what rule to follow but probably something 3244 like: N_MAIN takes precedence over "main" no matter what 3245 objfile it is in; If there is more than one N_MAIN, choose 3246 the one in the symfile_objfile; If there is more than one 3247 N_MAIN within a given objfile, complain() and choose 3248 arbitrarily. (kingdon) */ 3249 if (name != NULL) 3250 set_main_name (name); 3251 break; 3252 3253 /* The following symbol types can be ignored. */ 3254 case N_OBJ: /* Solaris 2: Object file dir and name */ 3255 case N_PATCH: /* Solaris2: Patch Run Time Checker. */ 3256 /* N_UNDF: Solaris 2: file separator mark */ 3257 /* N_UNDF: -- we will never encounter it, since we only process one 3258 file's symbols at once. */ 3259 case N_ENDM: /* Solaris 2: End of module */ 3260 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ 3261 break; 3262 } 3263 3264 /* '#' is a GNU C extension to allow one symbol to refer to another 3265 related symbol. 3266 3267 Generally this is used so that an alias can refer to its main 3268 symbol. */ 3269 if (name[0] == '#') 3270 { 3271 /* Initialize symbol reference names and determine if this is 3272 a definition. If symbol reference is being defined, go 3273 ahead and add it. Otherwise, just return sym. */ 3274 3275 char *s = name; 3276 int refnum; 3277 3278 /* If this stab defines a new reference ID that is not on the 3279 reference list, then put it on the reference list. 3280 3281 We go ahead and advance NAME past the reference, even though 3282 it is not strictly necessary at this time. */ 3283 refnum = symbol_reference_defined (&s); 3284 if (refnum >= 0) 3285 if (!ref_search (refnum)) 3286 ref_add (refnum, 0, name, valu); 3287 name = s; 3288 } 3289 3290 3291 previous_stab_code = type; 3292} 3293 3294/* FIXME: The only difference between this and elfstab_build_psymtabs 3295 is the call to install_minimal_symbols for elf, and the support for 3296 split sections. If the differences are really that small, the code 3297 should be shared. */ 3298 3299/* Scan and build partial symbols for an coff symbol file. 3300 The coff file has already been processed to get its minimal symbols. 3301 3302 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read 3303 rolled into one. 3304 3305 OBJFILE is the object file we are reading symbols from. 3306 ADDR is the address relative to which the symbols are (e.g. 3307 the base address of the text segment). 3308 MAINLINE is true if we are reading the main symbol 3309 table (as opposed to a shared lib or dynamically loaded file). 3310 TEXTADDR is the address of the text section. 3311 TEXTSIZE is the size of the text section. 3312 STABSECTS is the list of .stab sections in OBJFILE. 3313 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the 3314 .stabstr section exists. 3315 3316 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read, 3317 adjusted for coff details. */ 3318 3319void 3320coffstab_build_psymtabs (struct objfile *objfile, int mainline, 3321 CORE_ADDR textaddr, unsigned int textsize, 3322 struct stab_section_list *stabsects, 3323 file_ptr stabstroffset, unsigned int stabstrsize) 3324{ 3325 int val; 3326 bfd *sym_bfd = objfile->obfd; 3327 char *name = bfd_get_filename (sym_bfd); 3328 struct dbx_symfile_info *info; 3329 unsigned int stabsize; 3330 3331 /* There is already a dbx_symfile_info allocated by our caller. 3332 It might even contain some info from the coff symtab to help us. */ 3333 info = objfile->sym_stab_info; 3334 3335 DBX_TEXT_ADDR (objfile) = textaddr; 3336 DBX_TEXT_SIZE (objfile) = textsize; 3337 3338#define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */ 3339 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE; 3340 DBX_STRINGTAB_SIZE (objfile) = stabstrsize; 3341 3342 if (stabstrsize > bfd_get_size (sym_bfd)) 3343 error ("ridiculous string table size: %d bytes", stabstrsize); 3344 DBX_STRINGTAB (objfile) = (char *) 3345 obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1); 3346 OBJSTAT (objfile, sz_strtab += stabstrsize + 1); 3347 3348 /* Now read in the string table in one big gulp. */ 3349 3350 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET); 3351 if (val < 0) 3352 perror_with_name (name); 3353 val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd); 3354 if (val != stabstrsize) 3355 perror_with_name (name); 3356 3357 stabsread_new_init (); 3358 buildsym_new_init (); 3359 free_header_files (); 3360 init_header_files (); 3361 3362 processing_acc_compilation = 1; 3363 3364 /* In a coff file, we've already installed the minimal symbols that came 3365 from the coff (non-stab) symbol table, so always act like an 3366 incremental load here. */ 3367 if (stabsects->next == NULL) 3368 { 3369 stabsize = bfd_section_size (sym_bfd, stabsects->section); 3370 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile); 3371 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos; 3372 } 3373 else 3374 { 3375 struct stab_section_list *stabsect; 3376 3377 DBX_SYMCOUNT (objfile) = 0; 3378 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next) 3379 { 3380 stabsize = bfd_section_size (sym_bfd, stabsect->section); 3381 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile); 3382 } 3383 3384 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos; 3385 3386 symbuf_sections = stabsects->next; 3387 symbuf_left = bfd_section_size (sym_bfd, stabsects->section); 3388 symbuf_read = 0; 3389 } 3390 3391 dbx_symfile_read (objfile, 0); 3392} 3393 3394/* Scan and build partial symbols for an ELF symbol file. 3395 This ELF file has already been processed to get its minimal symbols, 3396 and any DWARF symbols that were in it. 3397 3398 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read 3399 rolled into one. 3400 3401 OBJFILE is the object file we are reading symbols from. 3402 ADDR is the address relative to which the symbols are (e.g. 3403 the base address of the text segment). 3404 MAINLINE is true if we are reading the main symbol 3405 table (as opposed to a shared lib or dynamically loaded file). 3406 STABSECT is the BFD section information for the .stab section. 3407 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the 3408 .stabstr section exists. 3409 3410 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read, 3411 adjusted for elf details. */ 3412 3413void 3414elfstab_build_psymtabs (struct objfile *objfile, int mainline, 3415 asection *stabsect, 3416 file_ptr stabstroffset, unsigned int stabstrsize) 3417{ 3418 int val; 3419 bfd *sym_bfd = objfile->obfd; 3420 char *name = bfd_get_filename (sym_bfd); 3421 struct dbx_symfile_info *info; 3422 struct cleanup *back_to = NULL; 3423 3424 /* There is already a dbx_symfile_info allocated by our caller. 3425 It might even contain some info from the ELF symtab to help us. */ 3426 info = objfile->sym_stab_info; 3427 3428 /* Find the first and last text address. dbx_symfile_read seems to 3429 want this. */ 3430 find_text_range (sym_bfd, objfile); 3431 3432#define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */ 3433 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE; 3434 DBX_SYMCOUNT (objfile) 3435 = bfd_section_size (objfile->obfd, stabsect) / DBX_SYMBOL_SIZE (objfile); 3436 DBX_STRINGTAB_SIZE (objfile) = stabstrsize; 3437 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; 3438 DBX_STAB_SECTION (objfile) = stabsect; 3439 3440 if (stabstrsize > bfd_get_size (sym_bfd)) 3441 error ("ridiculous string table size: %d bytes", stabstrsize); 3442 DBX_STRINGTAB (objfile) = (char *) 3443 obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1); 3444 OBJSTAT (objfile, sz_strtab += stabstrsize + 1); 3445 3446 /* Now read in the string table in one big gulp. */ 3447 3448 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET); 3449 if (val < 0) 3450 perror_with_name (name); 3451 val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd); 3452 if (val != stabstrsize) 3453 perror_with_name (name); 3454 3455 stabsread_new_init (); 3456 buildsym_new_init (); 3457 free_header_files (); 3458 init_header_files (); 3459 3460 processing_acc_compilation = 1; 3461 3462 symbuf_read = 0; 3463 symbuf_left = bfd_section_size (objfile->obfd, stabsect); 3464 stabs_data = symfile_relocate_debug_section (objfile->obfd, stabsect, NULL); 3465 if (stabs_data) 3466 back_to = make_cleanup (free_current_contents, (void *) &stabs_data); 3467 3468 /* In an elf file, we've already installed the minimal symbols that came 3469 from the elf (non-stab) symbol table, so always act like an 3470 incremental load here. dbx_symfile_read should not generate any new 3471 minimal symbols, since we will have already read the ELF dynamic symbol 3472 table and normal symbol entries won't be in the ".stab" section; but in 3473 case it does, it will install them itself. */ 3474 dbx_symfile_read (objfile, 0); 3475 3476 if (back_to) 3477 do_cleanups (back_to); 3478} 3479 3480/* Scan and build partial symbols for a file with special sections for stabs 3481 and stabstrings. The file has already been processed to get its minimal 3482 symbols, and any other symbols that might be necessary to resolve GSYMs. 3483 3484 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read 3485 rolled into one. 3486 3487 OBJFILE is the object file we are reading symbols from. 3488 ADDR is the address relative to which the symbols are (e.g. the base address 3489 of the text segment). 3490 MAINLINE is true if we are reading the main symbol table (as opposed to a 3491 shared lib or dynamically loaded file). 3492 STAB_NAME is the name of the section that contains the stabs. 3493 STABSTR_NAME is the name of the section that contains the stab strings. 3494 3495 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */ 3496 3497void 3498stabsect_build_psymtabs (struct objfile *objfile, int mainline, char *stab_name, 3499 char *stabstr_name, char *text_name) 3500{ 3501 int val; 3502 bfd *sym_bfd = objfile->obfd; 3503 char *name = bfd_get_filename (sym_bfd); 3504 asection *stabsect; 3505 asection *stabstrsect; 3506 asection *text_sect; 3507 3508 stabsect = bfd_get_section_by_name (sym_bfd, stab_name); 3509 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name); 3510 3511 if (!stabsect) 3512 return; 3513 3514 if (!stabstrsect) 3515 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)", 3516 stab_name, stabstr_name); 3517 3518 objfile->sym_stab_info = (struct dbx_symfile_info *) 3519 xmalloc (sizeof (struct dbx_symfile_info)); 3520 memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info)); 3521 3522 text_sect = bfd_get_section_by_name (sym_bfd, text_name); 3523 if (!text_sect) 3524 error ("Can't find %s section in symbol file", text_name); 3525 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect); 3526 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect); 3527 3528 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist); 3529 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect) 3530 / DBX_SYMBOL_SIZE (objfile); 3531 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect); 3532 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */ 3533 3534 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd)) 3535 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile)); 3536 DBX_STRINGTAB (objfile) = (char *) 3537 obstack_alloc (&objfile->objfile_obstack, DBX_STRINGTAB_SIZE (objfile) + 1); 3538 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1); 3539 3540 /* Now read in the string table in one big gulp. */ 3541 3542 val = bfd_get_section_contents (sym_bfd, /* bfd */ 3543 stabstrsect, /* bfd section */ 3544 DBX_STRINGTAB (objfile), /* input buffer */ 3545 0, /* offset into section */ 3546 DBX_STRINGTAB_SIZE (objfile)); /* amount to read */ 3547 3548 if (!val) 3549 perror_with_name (name); 3550 3551 stabsread_new_init (); 3552 buildsym_new_init (); 3553 free_header_files (); 3554 init_header_files (); 3555 3556 /* Now, do an incremental load */ 3557 3558 processing_acc_compilation = 1; 3559 dbx_symfile_read (objfile, 0); 3560} 3561 3562static struct sym_fns aout_sym_fns = 3563{ 3564 bfd_target_aout_flavour, 3565 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */ 3566 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */ 3567 dbx_symfile_read, /* sym_read: read a symbol file into symtab */ 3568 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */ 3569 default_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */ 3570 NULL /* next: pointer to next struct sym_fns */ 3571}; 3572 3573void 3574_initialize_dbxread (void) 3575{ 3576 add_symtab_fns (&aout_sym_fns); 3577} 3578