1 /* Read coff symbol tables and convert to internal format, for GDB. 2 Copyright (C) 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 3 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 4 Free Software Foundation, Inc. 5 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu). 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "symtab.h" 24 #include "gdbtypes.h" 25 #include "demangle.h" 26 #include "breakpoint.h" 27 28 #include "bfd.h" 29 #include "gdb_obstack.h" 30 31 #include "gdb_string.h" 32 #include <ctype.h> 33 34 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */ 35 #include "libcoff.h" /* FIXME secret internal data from BFD */ 36 #include "objfiles.h" 37 #include "buildsym.h" 38 #include "gdb-stabs.h" 39 #include "stabsread.h" 40 #include "complaints.h" 41 #include "target.h" 42 #include "gdb_assert.h" 43 #include "block.h" 44 #include "dictionary.h" 45 46 #include "coff-pe-read.h" 47 48 extern void _initialize_coffread (void); 49 50 struct coff_symfile_info 51 { 52 file_ptr min_lineno_offset; /* Where in file lowest line#s are */ 53 file_ptr max_lineno_offset; /* 1+last byte of line#s in file */ 54 55 CORE_ADDR textaddr; /* Addr of .text section. */ 56 unsigned int textsize; /* Size of .text section. */ 57 struct stab_section_list *stabsects; /* .stab sections. */ 58 asection *stabstrsect; /* Section pointer for .stab section */ 59 char *stabstrdata; 60 }; 61 62 /* Translate an external name string into a user-visible name. */ 63 #define EXTERNAL_NAME(string, abfd) \ 64 (string[0] == bfd_get_symbol_leading_char(abfd)? string+1: string) 65 66 /* To be an sdb debug type, type must have at least a basic or primary 67 derived type. Using this rather than checking against T_NULL is 68 said to prevent core dumps if we try to operate on Michael Bloom 69 dbx-in-coff file. */ 70 71 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK)) 72 73 /* Core address of start and end of text of current source file. 74 This comes from a ".text" symbol where x_nlinno > 0. */ 75 76 static CORE_ADDR current_source_start_addr; 77 static CORE_ADDR current_source_end_addr; 78 79 /* The addresses of the symbol table stream and number of symbols 80 of the object file we are reading (as copied into core). */ 81 82 static bfd *nlist_bfd_global; 83 static int nlist_nsyms_global; 84 85 86 /* Pointers to scratch storage, used for reading raw symbols and auxents. */ 87 88 static char *temp_sym; 89 static char *temp_aux; 90 91 /* Local variables that hold the shift and mask values for the 92 COFF file that we are currently reading. These come back to us 93 from BFD, and are referenced by their macro names, as well as 94 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF 95 macros from include/coff/internal.h . */ 96 97 static unsigned local_n_btmask; 98 static unsigned local_n_btshft; 99 static unsigned local_n_tmask; 100 static unsigned local_n_tshift; 101 102 #define N_BTMASK local_n_btmask 103 #define N_BTSHFT local_n_btshft 104 #define N_TMASK local_n_tmask 105 #define N_TSHIFT local_n_tshift 106 107 /* Local variables that hold the sizes in the file of various COFF structures. 108 (We only need to know this to read them from the file -- BFD will then 109 translate the data in them, into `internal_xxx' structs in the right 110 byte order, alignment, etc.) */ 111 112 static unsigned local_linesz; 113 static unsigned local_symesz; 114 static unsigned local_auxesz; 115 116 /* This is set if this is a PE format file. */ 117 118 static int pe_file; 119 120 /* Chain of typedefs of pointers to empty struct/union types. 121 They are chained thru the SYMBOL_VALUE_CHAIN. */ 122 123 static struct symbol *opaque_type_chain[HASHSIZE]; 124 125 /* Simplified internal version of coff symbol table information */ 126 127 struct coff_symbol 128 { 129 char *c_name; 130 int c_symnum; /* symbol number of this entry */ 131 int c_naux; /* 0 if syment only, 1 if syment + auxent, etc */ 132 long c_value; 133 int c_sclass; 134 int c_secnum; 135 unsigned int c_type; 136 }; 137 138 extern void stabsread_clear_cache (void); 139 140 static struct type *coff_read_struct_type (int, int, int, 141 struct objfile *); 142 143 static struct type *decode_base_type (struct coff_symbol *, 144 unsigned int, union internal_auxent *, 145 struct objfile *); 146 147 static struct type *decode_type (struct coff_symbol *, unsigned int, 148 union internal_auxent *, 149 struct objfile *); 150 151 static struct type *decode_function_type (struct coff_symbol *, 152 unsigned int, 153 union internal_auxent *, 154 struct objfile *); 155 156 static struct type *coff_read_enum_type (int, int, int, 157 struct objfile *); 158 159 static struct symbol *process_coff_symbol (struct coff_symbol *, 160 union internal_auxent *, 161 struct objfile *); 162 163 static void patch_opaque_types (struct symtab *); 164 165 static void enter_linenos (long, int, int, struct objfile *); 166 167 static void free_linetab (void); 168 169 static void free_linetab_cleanup (void *ignore); 170 171 static int init_lineno (bfd *, long, int); 172 173 static char *getsymname (struct internal_syment *); 174 175 static char *coff_getfilename (union internal_auxent *); 176 177 static void free_stringtab (void); 178 179 static void free_stringtab_cleanup (void *ignore); 180 181 static int init_stringtab (bfd *, long); 182 183 static void read_one_sym (struct coff_symbol *, 184 struct internal_syment *, union internal_auxent *); 185 186 static void coff_symtab_read (long, unsigned int, struct objfile *); 187 188 /* We are called once per section from coff_symfile_read. We 189 need to examine each section we are passed, check to see 190 if it is something we are interested in processing, and 191 if so, stash away some access information for the section. 192 193 FIXME: The section names should not be hardwired strings (what 194 should they be? I don't think most object file formats have enough 195 section flags to specify what kind of debug section it is 196 -kingdon). */ 197 198 static void 199 coff_locate_sections (bfd *abfd, asection *sectp, void *csip) 200 { 201 struct coff_symfile_info *csi; 202 const char *name; 203 204 csi = (struct coff_symfile_info *) csip; 205 name = bfd_get_section_name (abfd, sectp); 206 if (strcmp (name, ".text") == 0) 207 { 208 csi->textaddr = bfd_section_vma (abfd, sectp); 209 csi->textsize += bfd_section_size (abfd, sectp); 210 } 211 else if (strncmp (name, ".text", sizeof ".text" - 1) == 0) 212 { 213 csi->textsize += bfd_section_size (abfd, sectp); 214 } 215 else if (strcmp (name, ".stabstr") == 0) 216 { 217 csi->stabstrsect = sectp; 218 } 219 else if (strncmp (name, ".stab", sizeof ".stab" - 1) == 0) 220 { 221 const char *s; 222 223 /* We can have multiple .stab sections if linked with 224 --split-by-reloc. */ 225 for (s = name + sizeof ".stab" - 1; *s != '\0'; s++) 226 if (!isdigit (*s)) 227 break; 228 if (*s == '\0') 229 { 230 struct stab_section_list *n, **pn; 231 232 n = ((struct stab_section_list *) 233 xmalloc (sizeof (struct stab_section_list))); 234 n->section = sectp; 235 n->next = NULL; 236 for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next) 237 ; 238 *pn = n; 239 240 /* This will be run after coffstab_build_psymtabs is called 241 in coff_symfile_read, at which point we no longer need 242 the information. */ 243 make_cleanup (xfree, n); 244 } 245 } 246 } 247 248 /* Return the section_offsets* that CS points to. */ 249 static int cs_to_section (struct coff_symbol *, struct objfile *); 250 251 struct find_targ_sec_arg 252 { 253 int targ_index; 254 asection **resultp; 255 }; 256 257 static void 258 find_targ_sec (bfd *abfd, asection *sect, void *obj) 259 { 260 struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj; 261 if (sect->target_index == args->targ_index) 262 *args->resultp = sect; 263 } 264 265 /* Return the bfd_section that CS points to. */ 266 static struct bfd_section* 267 cs_to_bfd_section (struct coff_symbol *cs, struct objfile *objfile) 268 { 269 asection *sect = NULL; 270 struct find_targ_sec_arg args; 271 272 args.targ_index = cs->c_secnum; 273 args.resultp = § 274 bfd_map_over_sections (objfile->obfd, find_targ_sec, &args); 275 return sect; 276 } 277 278 /* Return the section number (SECT_OFF_*) that CS points to. */ 279 static int 280 cs_to_section (struct coff_symbol *cs, struct objfile *objfile) 281 { 282 asection *sect = cs_to_bfd_section (cs, objfile); 283 if (sect == NULL) 284 return SECT_OFF_TEXT (objfile); 285 return sect->index; 286 } 287 288 /* Return the address of the section of a COFF symbol. */ 289 290 static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *); 291 292 static CORE_ADDR 293 cs_section_address (struct coff_symbol *cs, bfd *abfd) 294 { 295 asection *sect = NULL; 296 struct find_targ_sec_arg args; 297 CORE_ADDR addr = 0; 298 299 args.targ_index = cs->c_secnum; 300 args.resultp = § 301 bfd_map_over_sections (abfd, find_targ_sec, &args); 302 if (sect != NULL) 303 addr = bfd_get_section_vma (objfile->obfd, sect); 304 return addr; 305 } 306 307 /* Look up a coff type-number index. Return the address of the slot 308 where the type for that index is stored. 309 The type-number is in INDEX. 310 311 This can be used for finding the type associated with that index 312 or for associating a new type with the index. */ 313 314 static struct type ** 315 coff_lookup_type (int index) 316 { 317 if (index >= type_vector_length) 318 { 319 int old_vector_length = type_vector_length; 320 321 type_vector_length *= 2; 322 if (index /* is still */ >= type_vector_length) 323 type_vector_length = index * 2; 324 325 type_vector = (struct type **) 326 xrealloc ((char *) type_vector, 327 type_vector_length * sizeof (struct type *)); 328 memset (&type_vector[old_vector_length], 0, 329 (type_vector_length - old_vector_length) * sizeof (struct type *)); 330 } 331 return &type_vector[index]; 332 } 333 334 /* Make sure there is a type allocated for type number index 335 and return the type object. 336 This can create an empty (zeroed) type object. */ 337 338 static struct type * 339 coff_alloc_type (int index) 340 { 341 struct type **type_addr = coff_lookup_type (index); 342 struct type *type = *type_addr; 343 344 /* If we are referring to a type not known at all yet, 345 allocate an empty type for it. 346 We will fill it in later if we find out how. */ 347 if (type == NULL) 348 { 349 type = alloc_type (current_objfile); 350 *type_addr = type; 351 } 352 return type; 353 } 354 355 /* Start a new symtab for a new source file. 356 This is called when a COFF ".file" symbol is seen; 357 it indicates the start of data for one original source file. */ 358 359 static void 360 coff_start_symtab (char *name) 361 { 362 start_symtab ( 363 /* We fill in the filename later. start_symtab puts 364 this pointer into last_source_file and we put it in 365 subfiles->name, which end_symtab frees; that's why 366 it must be malloc'd. */ 367 xstrdup (name), 368 /* We never know the directory name for COFF. */ 369 NULL, 370 /* The start address is irrelevant, since we set 371 last_source_start_addr in coff_end_symtab. */ 372 0); 373 record_debugformat ("COFF"); 374 } 375 376 /* Save the vital information from when starting to read a file, 377 for use when closing off the current file. 378 NAME is the file name the symbols came from, START_ADDR is the first 379 text address for the file, and SIZE is the number of bytes of text. */ 380 381 static void 382 complete_symtab (char *name, CORE_ADDR start_addr, unsigned int size) 383 { 384 if (last_source_file != NULL) 385 xfree (last_source_file); 386 last_source_file = xstrdup (name); 387 current_source_start_addr = start_addr; 388 current_source_end_addr = start_addr + size; 389 } 390 391 /* Finish the symbol definitions for one main source file, 392 close off all the lexical contexts for that file 393 (creating struct block's for them), then make the 394 struct symtab for that file and put it in the list of all such. */ 395 396 static void 397 coff_end_symtab (struct objfile *objfile) 398 { 399 struct symtab *symtab; 400 401 last_source_start_addr = current_source_start_addr; 402 403 symtab = end_symtab (current_source_end_addr, objfile, SECT_OFF_TEXT (objfile)); 404 405 if (symtab != NULL) 406 free_named_symtabs (symtab->filename); 407 408 /* Reinitialize for beginning of new file. */ 409 last_source_file = NULL; 410 } 411 412 static struct minimal_symbol * 413 record_minimal_symbol (struct coff_symbol *cs, CORE_ADDR address, 414 enum minimal_symbol_type type, int section, 415 struct objfile *objfile) 416 { 417 struct bfd_section *bfd_section; 418 /* We don't want TDESC entry points in the minimal symbol table */ 419 if (cs->c_name[0] == '@') 420 return NULL; 421 422 bfd_section = cs_to_bfd_section (cs, objfile); 423 return prim_record_minimal_symbol_and_info (cs->c_name, address, type, 424 section, bfd_section, objfile); 425 } 426 427 /* coff_symfile_init () 428 is the coff-specific initialization routine for reading symbols. 429 It is passed a struct objfile which contains, among other things, 430 the BFD for the file whose symbols are being read, and a slot for 431 a pointer to "private data" which we fill with cookies and other 432 treats for coff_symfile_read (). 433 434 We will only be called if this is a COFF or COFF-like file. 435 BFD handles figuring out the format of the file, and code in symtab.c 436 uses BFD's determination to vector to us. 437 438 The ultimate result is a new symtab (or, FIXME, eventually a psymtab). */ 439 440 static void 441 coff_symfile_init (struct objfile *objfile) 442 { 443 /* Allocate struct to keep track of stab reading. */ 444 objfile->deprecated_sym_stab_info = (struct dbx_symfile_info *) 445 xmalloc (sizeof (struct dbx_symfile_info)); 446 447 memset (objfile->deprecated_sym_stab_info, 0, 448 sizeof (struct dbx_symfile_info)); 449 450 /* Allocate struct to keep track of the symfile */ 451 objfile->deprecated_sym_private = xmalloc (sizeof (struct coff_symfile_info)); 452 453 memset (objfile->deprecated_sym_private, 0, sizeof (struct coff_symfile_info)); 454 455 /* COFF objects may be reordered, so set OBJF_REORDERED. If we 456 find this causes a significant slowdown in gdb then we could 457 set it in the debug symbol readers only when necessary. */ 458 objfile->flags |= OBJF_REORDERED; 459 460 init_entry_point_info (objfile); 461 } 462 463 /* This function is called for every section; it finds the outer limits 464 of the line table (minimum and maximum file offset) so that the 465 mainline code can read the whole thing for efficiency. */ 466 467 static void 468 find_linenos (bfd *abfd, struct bfd_section *asect, void *vpinfo) 469 { 470 struct coff_symfile_info *info; 471 int size, count; 472 file_ptr offset, maxoff; 473 474 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ 475 count = asect->lineno_count; 476 /* End of warning */ 477 478 if (count == 0) 479 return; 480 size = count * local_linesz; 481 482 info = (struct coff_symfile_info *) vpinfo; 483 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ 484 offset = asect->line_filepos; 485 /* End of warning */ 486 487 if (offset < info->min_lineno_offset || info->min_lineno_offset == 0) 488 info->min_lineno_offset = offset; 489 490 maxoff = offset + size; 491 if (maxoff > info->max_lineno_offset) 492 info->max_lineno_offset = maxoff; 493 } 494 495 496 /* The BFD for this file -- only good while we're actively reading 497 symbols into a psymtab or a symtab. */ 498 499 static bfd *symfile_bfd; 500 501 /* Read a symbol file, after initialization by coff_symfile_init. */ 502 503 static void 504 coff_symfile_read (struct objfile *objfile, int mainline) 505 { 506 struct coff_symfile_info *info; 507 struct dbx_symfile_info *dbxinfo; 508 bfd *abfd = objfile->obfd; 509 coff_data_type *cdata = coff_data (abfd); 510 char *name = bfd_get_filename (abfd); 511 int val; 512 unsigned int num_symbols; 513 int symtab_offset; 514 int stringtab_offset; 515 struct cleanup *back_to, *cleanup_minimal_symbols; 516 int stabstrsize; 517 int len; 518 char * target; 519 520 info = (struct coff_symfile_info *) objfile->deprecated_sym_private; 521 dbxinfo = objfile->deprecated_sym_stab_info; 522 symfile_bfd = abfd; /* Kludge for swap routines */ 523 524 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */ 525 num_symbols = bfd_get_symcount (abfd); /* How many syms */ 526 symtab_offset = cdata->sym_filepos; /* Symbol table file offset */ 527 stringtab_offset = symtab_offset + /* String table file offset */ 528 num_symbols * cdata->local_symesz; 529 530 /* Set a few file-statics that give us specific information about 531 the particular COFF file format we're reading. */ 532 local_n_btmask = cdata->local_n_btmask; 533 local_n_btshft = cdata->local_n_btshft; 534 local_n_tmask = cdata->local_n_tmask; 535 local_n_tshift = cdata->local_n_tshift; 536 local_linesz = cdata->local_linesz; 537 local_symesz = cdata->local_symesz; 538 local_auxesz = cdata->local_auxesz; 539 540 /* Allocate space for raw symbol and aux entries, based on their 541 space requirements as reported by BFD. */ 542 temp_sym = (char *) xmalloc 543 (cdata->local_symesz + cdata->local_auxesz); 544 temp_aux = temp_sym + cdata->local_symesz; 545 back_to = make_cleanup (free_current_contents, &temp_sym); 546 547 /* We need to know whether this is a PE file, because in PE files, 548 unlike standard COFF files, symbol values are stored as offsets 549 from the section address, rather than as absolute addresses. 550 FIXME: We should use BFD to read the symbol table, and thus avoid 551 this problem. */ 552 pe_file = 553 strncmp (bfd_get_target (objfile->obfd), "pe", 2) == 0 554 || strncmp (bfd_get_target (objfile->obfd), "epoc-pe", 7) == 0; 555 556 /* End of warning */ 557 558 info->min_lineno_offset = 0; 559 info->max_lineno_offset = 0; 560 561 /* Only read line number information if we have symbols. 562 563 On Windows NT, some of the system's DLL's have sections with 564 PointerToLinenumbers fields that are non-zero, but point at 565 random places within the image file. (In the case I found, 566 KERNEL32.DLL's .text section has a line number info pointer that 567 points into the middle of the string `lib\\i386\kernel32.dll'.) 568 569 However, these DLL's also have no symbols. The line number 570 tables are meaningless without symbols. And in fact, GDB never 571 uses the line number information unless there are symbols. So we 572 can avoid spurious error messages (and maybe run a little 573 faster!) by not even reading the line number table unless we have 574 symbols. */ 575 if (num_symbols > 0) 576 { 577 /* Read the line number table, all at once. */ 578 bfd_map_over_sections (abfd, find_linenos, (void *) info); 579 580 make_cleanup (free_linetab_cleanup, 0 /*ignore*/); 581 val = init_lineno (abfd, info->min_lineno_offset, 582 info->max_lineno_offset - info->min_lineno_offset); 583 if (val < 0) 584 error (_("\"%s\": error reading line numbers."), name); 585 } 586 587 /* Now read the string table, all at once. */ 588 589 make_cleanup (free_stringtab_cleanup, 0 /*ignore*/); 590 val = init_stringtab (abfd, stringtab_offset); 591 if (val < 0) 592 error (_("\"%s\": can't get string table"), name); 593 594 init_minimal_symbol_collection (); 595 cleanup_minimal_symbols = make_cleanup_discard_minimal_symbols (); 596 597 /* Now that the executable file is positioned at symbol table, 598 process it and define symbols accordingly. */ 599 600 coff_symtab_read ((long) symtab_offset, num_symbols, objfile); 601 602 /* Install any minimal symbols that have been collected as the current 603 minimal symbols for this objfile. */ 604 605 install_minimal_symbols (objfile); 606 607 /* Free the installed minimal symbol data. */ 608 do_cleanups (cleanup_minimal_symbols); 609 610 /* If we are reinitializing, or if we have not loaded syms yet, 611 empty the psymtab. "mainline" is cleared so the *_read_psymtab 612 functions do not all re-initialize it. */ 613 if (mainline) 614 { 615 init_psymbol_list (objfile, 0); 616 mainline = 0; 617 } 618 619 bfd_map_over_sections (abfd, coff_locate_sections, (void *) info); 620 621 if (info->stabsects) 622 { 623 if (!info->stabstrsect) 624 { 625 error (_("The debugging information in `%s' is corrupted.\n" 626 "The file has a `.stabs' section, but no `.stabstr' section."), 627 name); 628 } 629 630 /* FIXME: dubious. Why can't we use something normal like 631 bfd_get_section_contents? */ 632 bfd_seek (abfd, abfd->where, 0); 633 634 stabstrsize = bfd_section_size (abfd, info->stabstrsect); 635 636 coffstab_build_psymtabs (objfile, 637 mainline, 638 info->textaddr, info->textsize, 639 info->stabsects, 640 info->stabstrsect->filepos, stabstrsize); 641 } 642 if (dwarf2_has_info (objfile)) 643 { 644 /* DWARF2 sections. */ 645 dwarf2_build_psymtabs (objfile, mainline); 646 } 647 648 dwarf2_build_frame_info (objfile); 649 650 do_cleanups (back_to); 651 } 652 653 static void 654 coff_new_init (struct objfile *ignore) 655 { 656 } 657 658 /* Perform any local cleanups required when we are done with a particular 659 objfile. I.E, we are in the process of discarding all symbol information 660 for an objfile, freeing up all memory held for it, and unlinking the 661 objfile struct from the global list of known objfiles. */ 662 663 static void 664 coff_symfile_finish (struct objfile *objfile) 665 { 666 if (objfile->deprecated_sym_private != NULL) 667 { 668 xfree (objfile->deprecated_sym_private); 669 } 670 671 /* Let stabs reader clean up */ 672 stabsread_clear_cache (); 673 674 dwarf2_free_objfile (objfile); 675 } 676 677 678 /* Given pointers to a symbol table in coff style exec file, 679 analyze them and create struct symtab's describing the symbols. 680 NSYMS is the number of symbols in the symbol table. 681 We read them one at a time using read_one_sym (). */ 682 683 static void 684 coff_symtab_read (long symtab_offset, unsigned int nsyms, 685 struct objfile *objfile) 686 { 687 struct gdbarch *gdbarch = get_objfile_arch (objfile); 688 struct context_stack *new; 689 struct coff_symbol coff_symbol; 690 struct coff_symbol *cs = &coff_symbol; 691 static struct internal_syment main_sym; 692 static union internal_auxent main_aux; 693 struct coff_symbol fcn_cs_saved; 694 static struct internal_syment fcn_sym_saved; 695 static union internal_auxent fcn_aux_saved; 696 struct symtab *s; 697 /* A .file is open. */ 698 int in_source_file = 0; 699 int next_file_symnum = -1; 700 /* Name of the current file. */ 701 char *filestring = ""; 702 int depth = 0; 703 int fcn_first_line = 0; 704 CORE_ADDR fcn_first_line_addr = 0; 705 int fcn_last_line = 0; 706 int fcn_start_addr = 0; 707 long fcn_line_ptr = 0; 708 int val; 709 CORE_ADDR tmpaddr; 710 struct minimal_symbol *msym; 711 712 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous.... 713 it's hard to know I've really worked around it. The fix should be 714 harmless, anyway). The symptom of the bug is that the first 715 fread (in read_one_sym), will (in my example) actually get data 716 from file offset 268, when the fseek was to 264 (and ftell shows 717 264). This causes all hell to break loose. I was unable to 718 reproduce this on a short test program which operated on the same 719 file, performing (I think) the same sequence of operations. 720 721 It stopped happening when I put in this (former) rewind(). 722 723 FIXME: Find out if this has been reported to Sun, whether it has 724 been fixed in a later release, etc. */ 725 726 bfd_seek (objfile->obfd, 0, 0); 727 728 /* Position to read the symbol table. */ 729 val = bfd_seek (objfile->obfd, (long) symtab_offset, 0); 730 if (val < 0) 731 perror_with_name (objfile->name); 732 733 current_objfile = objfile; 734 nlist_bfd_global = objfile->obfd; 735 nlist_nsyms_global = nsyms; 736 last_source_file = NULL; 737 memset (opaque_type_chain, 0, sizeof opaque_type_chain); 738 739 if (type_vector) /* Get rid of previous one */ 740 xfree (type_vector); 741 type_vector_length = 160; 742 type_vector = (struct type **) 743 xmalloc (type_vector_length * sizeof (struct type *)); 744 memset (type_vector, 0, type_vector_length * sizeof (struct type *)); 745 746 coff_start_symtab (""); 747 748 symnum = 0; 749 while (symnum < nsyms) 750 { 751 QUIT; /* Make this command interruptable. */ 752 753 read_one_sym (cs, &main_sym, &main_aux); 754 755 if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) 756 { 757 if (last_source_file) 758 coff_end_symtab (objfile); 759 760 coff_start_symtab ("_globals_"); 761 /* coff_start_symtab will set the language of this symtab to 762 language_unknown, since such a ``file name'' is not 763 recognized. Override that with the minimal language to 764 allow printing values in this symtab. */ 765 current_subfile->language = language_minimal; 766 complete_symtab ("_globals_", 0, 0); 767 /* done with all files, everything from here on out is globals */ 768 } 769 770 /* Special case for file with type declarations only, no text. */ 771 if (!last_source_file && SDB_TYPE (cs->c_type) 772 && cs->c_secnum == N_DEBUG) 773 complete_symtab (filestring, 0, 0); 774 775 /* Typedefs should not be treated as symbol definitions. */ 776 if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF) 777 { 778 /* Record all functions -- external and static -- in minsyms. */ 779 int section = cs_to_section (cs, objfile); 780 tmpaddr = cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 781 record_minimal_symbol (cs, tmpaddr, mst_text, section, objfile); 782 783 fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr; 784 fcn_start_addr = tmpaddr; 785 fcn_cs_saved = *cs; 786 fcn_sym_saved = main_sym; 787 fcn_aux_saved = main_aux; 788 continue; 789 } 790 791 switch (cs->c_sclass) 792 { 793 case C_EFCN: 794 case C_EXTDEF: 795 case C_ULABEL: 796 case C_USTATIC: 797 case C_LINE: 798 case C_ALIAS: 799 case C_HIDDEN: 800 complaint (&symfile_complaints, _("Bad n_sclass for symbol %s"), 801 cs->c_name); 802 break; 803 804 case C_FILE: 805 /* c_value field contains symnum of next .file entry in table 806 or symnum of first global after last .file. */ 807 next_file_symnum = cs->c_value; 808 if (cs->c_naux > 0) 809 filestring = coff_getfilename (&main_aux); 810 else 811 filestring = ""; 812 813 /* Complete symbol table for last object file 814 containing debugging information. */ 815 if (last_source_file) 816 { 817 coff_end_symtab (objfile); 818 coff_start_symtab (filestring); 819 } 820 in_source_file = 1; 821 break; 822 823 /* C_LABEL is used for labels and static functions. Including 824 it here allows gdb to see static functions when no debug 825 info is available. */ 826 case C_LABEL: 827 /* However, labels within a function can make weird backtraces, 828 so filter them out (from phdm@macqel.be). */ 829 if (within_function) 830 break; 831 case C_STAT: 832 case C_THUMBLABEL: 833 case C_THUMBSTAT: 834 case C_THUMBSTATFUNC: 835 if (cs->c_name[0] == '.') 836 { 837 if (strcmp (cs->c_name, ".text") == 0) 838 { 839 /* FIXME: don't wire in ".text" as section name 840 or symbol name! */ 841 /* Check for in_source_file deals with case of 842 a file with debugging symbols 843 followed by a later file with no symbols. */ 844 if (in_source_file) 845 complete_symtab (filestring, 846 cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), 847 main_aux.x_scn.x_scnlen); 848 in_source_file = 0; 849 } 850 /* flush rest of '.' symbols */ 851 break; 852 } 853 else if (!SDB_TYPE (cs->c_type) 854 && cs->c_name[0] == 'L' 855 && (strncmp (cs->c_name, "LI%", 3) == 0 856 || strncmp (cs->c_name, "LF%", 3) == 0 857 || strncmp (cs->c_name, "LC%", 3) == 0 858 || strncmp (cs->c_name, "LP%", 3) == 0 859 || strncmp (cs->c_name, "LPB%", 4) == 0 860 || strncmp (cs->c_name, "LBB%", 4) == 0 861 || strncmp (cs->c_name, "LBE%", 4) == 0 862 || strncmp (cs->c_name, "LPBX%", 5) == 0)) 863 /* At least on a 3b1, gcc generates swbeg and string labels 864 that look like this. Ignore them. */ 865 break; 866 /* fall in for static symbols that don't start with '.' */ 867 case C_THUMBEXT: 868 case C_THUMBEXTFUNC: 869 case C_EXT: 870 { 871 /* Record it in the minimal symbols regardless of 872 SDB_TYPE. This parallels what we do for other debug 873 formats, and probably is needed to make 874 print_address_symbolic work right without the (now 875 gone) "set fast-symbolic-addr off" kludge. */ 876 877 enum minimal_symbol_type ms_type; 878 int sec; 879 880 if (cs->c_secnum == N_UNDEF) 881 { 882 /* This is a common symbol. See if the target 883 environment knows where it has been relocated to. */ 884 CORE_ADDR reladdr; 885 if (target_lookup_symbol (cs->c_name, &reladdr)) 886 { 887 /* Error in lookup; ignore symbol. */ 888 break; 889 } 890 tmpaddr = reladdr; 891 /* The address has already been relocated; make sure that 892 objfile_relocate doesn't relocate it again. */ 893 sec = -2; 894 ms_type = cs->c_sclass == C_EXT 895 || cs->c_sclass == C_THUMBEXT ? 896 mst_bss : mst_file_bss; 897 } 898 else if (cs->c_secnum == N_ABS) 899 { 900 /* Use the correct minimal symbol type (and don't 901 relocate) for absolute values. */ 902 ms_type = mst_abs; 903 sec = cs_to_section (cs, objfile); 904 tmpaddr = cs->c_value; 905 } 906 else 907 { 908 asection *bfd_section = cs_to_bfd_section (cs, objfile); 909 sec = cs_to_section (cs, objfile); 910 tmpaddr = cs->c_value; 911 /* Statics in a PE file also get relocated */ 912 if (cs->c_sclass == C_EXT 913 || cs->c_sclass == C_THUMBEXTFUNC 914 || cs->c_sclass == C_THUMBEXT 915 || (pe_file && (cs->c_sclass == C_STAT))) 916 tmpaddr += ANOFFSET (objfile->section_offsets, sec); 917 918 if (bfd_section->flags & SEC_CODE) 919 { 920 ms_type = 921 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC 922 || cs->c_sclass == C_THUMBEXT ? 923 mst_text : mst_file_text; 924 tmpaddr = gdbarch_smash_text_address (gdbarch, tmpaddr); 925 } 926 else if (bfd_section->flags & SEC_ALLOC 927 && bfd_section->flags & SEC_LOAD) 928 { 929 ms_type = 930 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? 931 mst_data : mst_file_data; 932 } 933 else if (bfd_section->flags & SEC_ALLOC) 934 { 935 ms_type = 936 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT ? 937 mst_bss : mst_file_bss; 938 } 939 else 940 ms_type = mst_unknown; 941 } 942 943 msym = record_minimal_symbol (cs, tmpaddr, ms_type, sec, objfile); 944 if (msym) 945 gdbarch_coff_make_msymbol_special (gdbarch, cs->c_sclass, msym); 946 947 if (SDB_TYPE (cs->c_type)) 948 { 949 struct symbol *sym; 950 sym = process_coff_symbol 951 (cs, &main_aux, objfile); 952 SYMBOL_VALUE (sym) = tmpaddr; 953 SYMBOL_SECTION (sym) = sec; 954 } 955 } 956 break; 957 958 case C_FCN: 959 if (strcmp (cs->c_name, ".bf") == 0) 960 { 961 within_function = 1; 962 963 /* value contains address of first non-init type code */ 964 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno 965 contains line number of '{' } */ 966 if (cs->c_naux != 1) 967 complaint (&symfile_complaints, 968 _("`.bf' symbol %d has no aux entry"), cs->c_symnum); 969 fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; 970 fcn_first_line_addr = cs->c_value; 971 972 /* Might want to check that locals are 0 and 973 context_stack_depth is zero, and complain if not. */ 974 975 depth = 0; 976 new = push_context (depth, fcn_start_addr); 977 fcn_cs_saved.c_name = getsymname (&fcn_sym_saved); 978 new->name = 979 process_coff_symbol (&fcn_cs_saved, &fcn_aux_saved, objfile); 980 } 981 else if (strcmp (cs->c_name, ".ef") == 0) 982 { 983 if (!within_function) 984 error (_("Bad coff function information.")); 985 /* the value of .ef is the address of epilogue code; 986 not useful for gdb. */ 987 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno 988 contains number of lines to '}' */ 989 990 if (context_stack_depth <= 0) 991 { /* We attempted to pop an empty context stack */ 992 complaint (&symfile_complaints, 993 _("`.ef' symbol without matching `.bf' symbol ignored starting at symnum %d"), 994 cs->c_symnum); 995 within_function = 0; 996 break; 997 } 998 999 new = pop_context (); 1000 /* Stack must be empty now. */ 1001 if (context_stack_depth > 0 || new == NULL) 1002 { 1003 complaint (&symfile_complaints, 1004 _("Unmatched .ef symbol(s) ignored starting at symnum %d"), 1005 cs->c_symnum); 1006 within_function = 0; 1007 break; 1008 } 1009 if (cs->c_naux != 1) 1010 { 1011 complaint (&symfile_complaints, 1012 _("`.ef' symbol %d has no aux entry"), cs->c_symnum); 1013 fcn_last_line = 0x7FFFFFFF; 1014 } 1015 else 1016 { 1017 fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno; 1018 } 1019 /* fcn_first_line is the line number of the opening '{'. 1020 Do not record it - because it would affect gdb's idea 1021 of the line number of the first statement of the function - 1022 except for one-line functions, for which it is also the line 1023 number of all the statements and of the closing '}', and 1024 for which we do not have any other statement-line-number. */ 1025 if (fcn_last_line == 1) 1026 record_line (current_subfile, fcn_first_line, 1027 gdbarch_addr_bits_remove (gdbarch, 1028 fcn_first_line_addr)); 1029 else 1030 enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line, 1031 objfile); 1032 1033 finish_block (new->name, &local_symbols, new->old_blocks, 1034 new->start_addr, 1035 fcn_cs_saved.c_value 1036 + fcn_aux_saved.x_sym.x_misc.x_fsize 1037 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)), 1038 objfile 1039 ); 1040 within_function = 0; 1041 } 1042 break; 1043 1044 case C_BLOCK: 1045 if (strcmp (cs->c_name, ".bb") == 0) 1046 { 1047 tmpaddr = cs->c_value; 1048 tmpaddr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1049 push_context (++depth, tmpaddr); 1050 } 1051 else if (strcmp (cs->c_name, ".eb") == 0) 1052 { 1053 if (context_stack_depth <= 0) 1054 { /* We attempted to pop an empty context stack */ 1055 complaint (&symfile_complaints, 1056 _("`.eb' symbol without matching `.bb' symbol ignored starting at symnum %d"), 1057 cs->c_symnum); 1058 break; 1059 } 1060 1061 new = pop_context (); 1062 if (depth-- != new->depth) 1063 { 1064 complaint (&symfile_complaints, 1065 _("Mismatched .eb symbol ignored starting at symnum %d"), 1066 symnum); 1067 break; 1068 } 1069 if (local_symbols && context_stack_depth > 0) 1070 { 1071 tmpaddr = 1072 cs->c_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1073 /* Make a block for the local symbols within. */ 1074 finish_block (0, &local_symbols, new->old_blocks, 1075 new->start_addr, tmpaddr, objfile); 1076 } 1077 /* Now pop locals of block just finished. */ 1078 local_symbols = new->locals; 1079 } 1080 break; 1081 1082 default: 1083 process_coff_symbol (cs, &main_aux, objfile); 1084 break; 1085 } 1086 } 1087 1088 if ((nsyms == 0) && (pe_file)) 1089 { 1090 /* We've got no debugging symbols, but it's a portable 1091 executable, so try to read the export table */ 1092 read_pe_exported_syms (objfile); 1093 } 1094 1095 if (last_source_file) 1096 coff_end_symtab (objfile); 1097 1098 /* Patch up any opaque types (references to types that are not defined 1099 in the file where they are referenced, e.g. "struct foo *bar"). */ 1100 ALL_OBJFILE_SYMTABS (objfile, s) 1101 patch_opaque_types (s); 1102 1103 current_objfile = NULL; 1104 } 1105 1106 /* Routines for reading headers and symbols from executable. */ 1107 1108 /* Read the next symbol, swap it, and return it in both internal_syment 1109 form, and coff_symbol form. Also return its first auxent, if any, 1110 in internal_auxent form, and skip any other auxents. */ 1111 1112 static void 1113 read_one_sym (struct coff_symbol *cs, 1114 struct internal_syment *sym, 1115 union internal_auxent *aux) 1116 { 1117 int i; 1118 bfd_size_type bytes; 1119 1120 cs->c_symnum = symnum; 1121 bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global); 1122 if (bytes != local_symesz) 1123 error ("%s: error reading symbols", current_objfile->name); 1124 bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym); 1125 cs->c_naux = sym->n_numaux & 0xff; 1126 if (cs->c_naux >= 1) 1127 { 1128 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); 1129 if (bytes != local_auxesz) 1130 error ("%s: error reading symbols", current_objfile->name); 1131 bfd_coff_swap_aux_in (symfile_bfd, temp_aux, sym->n_type, sym->n_sclass, 1132 0, cs->c_naux, (char *) aux); 1133 /* If more than one aux entry, read past it (only the first aux 1134 is important). */ 1135 for (i = 1; i < cs->c_naux; i++) 1136 { 1137 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global); 1138 if (bytes != local_auxesz) 1139 error ("%s: error reading symbols", current_objfile->name); 1140 } 1141 } 1142 cs->c_name = getsymname (sym); 1143 cs->c_value = sym->n_value; 1144 cs->c_sclass = (sym->n_sclass & 0xff); 1145 cs->c_secnum = sym->n_scnum; 1146 cs->c_type = (unsigned) sym->n_type; 1147 if (!SDB_TYPE (cs->c_type)) 1148 cs->c_type = 0; 1149 1150 #if 0 1151 if (cs->c_sclass & 128) 1152 printf (_("thumb symbol %s, class 0x%x\n"), cs->c_name, cs->c_sclass); 1153 #endif 1154 1155 symnum += 1 + cs->c_naux; 1156 1157 /* The PE file format stores symbol values as offsets within the 1158 section, rather than as absolute addresses. We correct that 1159 here, if the symbol has an appropriate storage class. FIXME: We 1160 should use BFD to read the symbols, rather than duplicating the 1161 work here. */ 1162 if (pe_file) 1163 { 1164 switch (cs->c_sclass) 1165 { 1166 case C_EXT: 1167 case C_THUMBEXT: 1168 case C_THUMBEXTFUNC: 1169 case C_SECTION: 1170 case C_NT_WEAK: 1171 case C_STAT: 1172 case C_THUMBSTAT: 1173 case C_THUMBSTATFUNC: 1174 case C_LABEL: 1175 case C_THUMBLABEL: 1176 case C_BLOCK: 1177 case C_FCN: 1178 case C_EFCN: 1179 if (cs->c_secnum != 0) 1180 cs->c_value += cs_section_address (cs, symfile_bfd); 1181 break; 1182 } 1183 } 1184 } 1185 1186 /* Support for string table handling */ 1187 1188 static char *stringtab = NULL; 1189 1190 static int 1191 init_stringtab (bfd *abfd, long offset) 1192 { 1193 long length; 1194 int val; 1195 unsigned char lengthbuf[4]; 1196 1197 free_stringtab (); 1198 1199 /* If the file is stripped, the offset might be zero, indicating no 1200 string table. Just return with `stringtab' set to null. */ 1201 if (offset == 0) 1202 return 0; 1203 1204 if (bfd_seek (abfd, offset, 0) < 0) 1205 return -1; 1206 1207 val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd); 1208 length = bfd_h_get_32 (symfile_bfd, lengthbuf); 1209 1210 /* If no string table is needed, then the file may end immediately 1211 after the symbols. Just return with `stringtab' set to null. */ 1212 if (val != sizeof lengthbuf || length < sizeof lengthbuf) 1213 return 0; 1214 1215 stringtab = (char *) xmalloc (length); 1216 /* This is in target format (probably not very useful, and not currently 1217 used), not host format. */ 1218 memcpy (stringtab, lengthbuf, sizeof lengthbuf); 1219 if (length == sizeof length) /* Empty table -- just the count */ 1220 return 0; 1221 1222 val = bfd_bread (stringtab + sizeof lengthbuf, length - sizeof lengthbuf, 1223 abfd); 1224 if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0') 1225 return -1; 1226 1227 return 0; 1228 } 1229 1230 static void 1231 free_stringtab (void) 1232 { 1233 if (stringtab) 1234 xfree (stringtab); 1235 stringtab = NULL; 1236 } 1237 1238 static void 1239 free_stringtab_cleanup (void *ignore) 1240 { 1241 free_stringtab (); 1242 } 1243 1244 static char * 1245 getsymname (struct internal_syment *symbol_entry) 1246 { 1247 static char buffer[SYMNMLEN + 1]; 1248 char *result; 1249 1250 if (symbol_entry->_n._n_n._n_zeroes == 0) 1251 { 1252 /* FIXME: Probably should be detecting corrupt symbol files by 1253 seeing whether offset points to within the stringtab. */ 1254 result = stringtab + symbol_entry->_n._n_n._n_offset; 1255 } 1256 else 1257 { 1258 strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN); 1259 buffer[SYMNMLEN] = '\0'; 1260 result = buffer; 1261 } 1262 return result; 1263 } 1264 1265 /* Extract the file name from the aux entry of a C_FILE symbol. Return 1266 only the last component of the name. Result is in static storage and 1267 is only good for temporary use. */ 1268 1269 static char * 1270 coff_getfilename (union internal_auxent *aux_entry) 1271 { 1272 static char buffer[BUFSIZ]; 1273 char *temp; 1274 char *result; 1275 1276 if (aux_entry->x_file.x_n.x_zeroes == 0) 1277 strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset); 1278 else 1279 { 1280 strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN); 1281 buffer[FILNMLEN] = '\0'; 1282 } 1283 result = buffer; 1284 1285 /* FIXME: We should not be throwing away the information about what 1286 directory. It should go into dirname of the symtab, or some such 1287 place. */ 1288 if ((temp = strrchr (result, '/')) != NULL) 1289 result = temp + 1; 1290 return (result); 1291 } 1292 1293 /* Support for line number handling. */ 1294 1295 static char *linetab = NULL; 1296 static long linetab_offset; 1297 static unsigned long linetab_size; 1298 1299 /* Read in all the line numbers for fast lookups later. Leave them in 1300 external (unswapped) format in memory; we'll swap them as we enter 1301 them into GDB's data structures. */ 1302 1303 static int 1304 init_lineno (bfd *abfd, long offset, int size) 1305 { 1306 int val; 1307 1308 linetab_offset = offset; 1309 linetab_size = size; 1310 1311 free_linetab (); 1312 1313 if (size == 0) 1314 return 0; 1315 1316 if (bfd_seek (abfd, offset, 0) < 0) 1317 return -1; 1318 1319 /* Allocate the desired table, plus a sentinel */ 1320 linetab = (char *) xmalloc (size + local_linesz); 1321 1322 val = bfd_bread (linetab, size, abfd); 1323 if (val != size) 1324 return -1; 1325 1326 /* Terminate it with an all-zero sentinel record */ 1327 memset (linetab + size, 0, local_linesz); 1328 1329 return 0; 1330 } 1331 1332 static void 1333 free_linetab (void) 1334 { 1335 if (linetab) 1336 xfree (linetab); 1337 linetab = NULL; 1338 } 1339 1340 static void 1341 free_linetab_cleanup (void *ignore) 1342 { 1343 free_linetab (); 1344 } 1345 1346 #if !defined (L_LNNO32) 1347 #define L_LNNO32(lp) ((lp)->l_lnno) 1348 #endif 1349 1350 static void 1351 enter_linenos (long file_offset, int first_line, 1352 int last_line, struct objfile *objfile) 1353 { 1354 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1355 char *rawptr; 1356 struct internal_lineno lptr; 1357 1358 if (!linetab) 1359 return; 1360 if (file_offset < linetab_offset) 1361 { 1362 complaint (&symfile_complaints, 1363 _("Line number pointer %ld lower than start of line numbers"), 1364 file_offset); 1365 if (file_offset > linetab_size) /* Too big to be an offset? */ 1366 return; 1367 file_offset += linetab_offset; /* Try reading at that linetab offset */ 1368 } 1369 1370 rawptr = &linetab[file_offset - linetab_offset]; 1371 1372 /* skip first line entry for each function */ 1373 rawptr += local_linesz; 1374 /* line numbers start at one for the first line of the function */ 1375 first_line--; 1376 1377 /* If the line number table is full (e.g. 64K lines in COFF debug 1378 info), the next function's L_LNNO32 might not be zero, so don't 1379 overstep the table's end in any case. */ 1380 while (rawptr <= &linetab[0] + linetab_size) 1381 { 1382 bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr); 1383 rawptr += local_linesz; 1384 /* The next function, or the sentinel, will have L_LNNO32 zero; 1385 we exit. */ 1386 if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line) 1387 { 1388 CORE_ADDR addr = lptr.l_addr.l_paddr; 1389 addr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1390 record_line (current_subfile, first_line + L_LNNO32 (&lptr), 1391 gdbarch_addr_bits_remove (gdbarch, addr)); 1392 } 1393 else 1394 break; 1395 } 1396 } 1397 1398 static void 1399 patch_type (struct type *type, struct type *real_type) 1400 { 1401 struct type *target = TYPE_TARGET_TYPE (type); 1402 struct type *real_target = TYPE_TARGET_TYPE (real_type); 1403 int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field); 1404 1405 TYPE_LENGTH (target) = TYPE_LENGTH (real_target); 1406 TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target); 1407 TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target, field_size); 1408 1409 memcpy (TYPE_FIELDS (target), TYPE_FIELDS (real_target), field_size); 1410 1411 if (TYPE_NAME (real_target)) 1412 { 1413 if (TYPE_NAME (target)) 1414 xfree (TYPE_NAME (target)); 1415 TYPE_NAME (target) = concat (TYPE_NAME (real_target), (char *)NULL); 1416 } 1417 } 1418 1419 /* Patch up all appropriate typedef symbols in the opaque_type_chains 1420 so that they can be used to print out opaque data structures properly. */ 1421 1422 static void 1423 patch_opaque_types (struct symtab *s) 1424 { 1425 struct block *b; 1426 struct dict_iterator iter; 1427 struct symbol *real_sym; 1428 1429 /* Go through the per-file symbols only */ 1430 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK); 1431 ALL_BLOCK_SYMBOLS (b, iter, real_sym) 1432 { 1433 /* Find completed typedefs to use to fix opaque ones. 1434 Remove syms from the chain when their types are stored, 1435 but search the whole chain, as there may be several syms 1436 from different files with the same name. */ 1437 if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF && 1438 SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN && 1439 TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR && 1440 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0) 1441 { 1442 char *name = SYMBOL_LINKAGE_NAME (real_sym); 1443 int hash = hashname (name); 1444 struct symbol *sym, *prev; 1445 1446 prev = 0; 1447 for (sym = opaque_type_chain[hash]; sym;) 1448 { 1449 if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0] && 1450 strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0) 1451 { 1452 if (prev) 1453 { 1454 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym); 1455 } 1456 else 1457 { 1458 opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym); 1459 } 1460 1461 patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym)); 1462 1463 if (prev) 1464 { 1465 sym = SYMBOL_VALUE_CHAIN (prev); 1466 } 1467 else 1468 { 1469 sym = opaque_type_chain[hash]; 1470 } 1471 } 1472 else 1473 { 1474 prev = sym; 1475 sym = SYMBOL_VALUE_CHAIN (sym); 1476 } 1477 } 1478 } 1479 } 1480 } 1481 1482 static int 1483 coff_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) 1484 { 1485 return gdbarch_sdb_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); 1486 } 1487 1488 static const struct symbol_register_ops coff_register_funcs = { 1489 coff_reg_to_regnum 1490 }; 1491 1492 static struct symbol * 1493 process_coff_symbol (struct coff_symbol *cs, 1494 union internal_auxent *aux, 1495 struct objfile *objfile) 1496 { 1497 struct symbol *sym 1498 = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, 1499 sizeof (struct symbol)); 1500 char *name; 1501 1502 memset (sym, 0, sizeof (struct symbol)); 1503 name = cs->c_name; 1504 name = EXTERNAL_NAME (name, objfile->obfd); 1505 SYMBOL_LANGUAGE (sym) = current_subfile->language; 1506 SYMBOL_SET_NAMES (sym, name, strlen (name), objfile); 1507 1508 /* default assumptions */ 1509 SYMBOL_VALUE (sym) = cs->c_value; 1510 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1511 SYMBOL_SECTION (sym) = cs_to_section (cs, objfile); 1512 1513 if (ISFCN (cs->c_type)) 1514 { 1515 SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1516 SYMBOL_TYPE (sym) = 1517 lookup_function_type (decode_function_type (cs, cs->c_type, aux, objfile)); 1518 1519 SYMBOL_CLASS (sym) = LOC_BLOCK; 1520 if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT 1521 || cs->c_sclass == C_THUMBSTATFUNC) 1522 add_symbol_to_list (sym, &file_symbols); 1523 else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT 1524 || cs->c_sclass == C_THUMBEXTFUNC) 1525 add_symbol_to_list (sym, &global_symbols); 1526 } 1527 else 1528 { 1529 SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile); 1530 switch (cs->c_sclass) 1531 { 1532 case C_NULL: 1533 break; 1534 1535 case C_AUTO: 1536 SYMBOL_CLASS (sym) = LOC_LOCAL; 1537 add_symbol_to_list (sym, &local_symbols); 1538 break; 1539 1540 case C_THUMBEXT: 1541 case C_THUMBEXTFUNC: 1542 case C_EXT: 1543 SYMBOL_CLASS (sym) = LOC_STATIC; 1544 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; 1545 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1546 add_symbol_to_list (sym, &global_symbols); 1547 break; 1548 1549 case C_THUMBSTAT: 1550 case C_THUMBSTATFUNC: 1551 case C_STAT: 1552 SYMBOL_CLASS (sym) = LOC_STATIC; 1553 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value; 1554 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 1555 if (within_function) 1556 { 1557 /* Static symbol of local scope */ 1558 add_symbol_to_list (sym, &local_symbols); 1559 } 1560 else 1561 { 1562 /* Static symbol at top level of file */ 1563 add_symbol_to_list (sym, &file_symbols); 1564 } 1565 break; 1566 1567 #ifdef C_GLBLREG /* AMD coff */ 1568 case C_GLBLREG: 1569 #endif 1570 case C_REG: 1571 SYMBOL_CLASS (sym) = LOC_REGISTER; 1572 SYMBOL_REGISTER_OPS (sym) = &coff_register_funcs; 1573 SYMBOL_VALUE (sym) = cs->c_value; 1574 add_symbol_to_list (sym, &local_symbols); 1575 break; 1576 1577 case C_THUMBLABEL: 1578 case C_LABEL: 1579 break; 1580 1581 case C_ARG: 1582 SYMBOL_CLASS (sym) = LOC_ARG; 1583 SYMBOL_IS_ARGUMENT (sym) = 1; 1584 add_symbol_to_list (sym, &local_symbols); 1585 break; 1586 1587 case C_REGPARM: 1588 SYMBOL_CLASS (sym) = LOC_REGISTER; 1589 SYMBOL_REGISTER_OPS (sym) = &coff_register_funcs; 1590 SYMBOL_IS_ARGUMENT (sym) = 1; 1591 SYMBOL_VALUE (sym) = cs->c_value; 1592 add_symbol_to_list (sym, &local_symbols); 1593 break; 1594 1595 case C_TPDEF: 1596 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 1597 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1598 1599 /* If type has no name, give it one */ 1600 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) 1601 { 1602 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR 1603 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC) 1604 { 1605 /* If we are giving a name to a type such as "pointer to 1606 foo" or "function returning foo", we better not set 1607 the TYPE_NAME. If the program contains "typedef char 1608 *caddr_t;", we don't want all variables of type char 1609 * to print as caddr_t. This is not just a 1610 consequence of GDB's type management; CC and GCC (at 1611 least through version 2.4) both output variables of 1612 either type char * or caddr_t with the type 1613 refering to the C_TPDEF symbol for caddr_t. If a future 1614 compiler cleans this up it GDB is not ready for it 1615 yet, but if it becomes ready we somehow need to 1616 disable this check (without breaking the PCC/GCC2.4 1617 case). 1618 1619 Sigh. 1620 1621 Fortunately, this check seems not to be necessary 1622 for anything except pointers or functions. */ 1623 ; 1624 } 1625 else 1626 TYPE_NAME (SYMBOL_TYPE (sym)) = 1627 concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL); 1628 } 1629 1630 /* Keep track of any type which points to empty structured type, 1631 so it can be filled from a definition from another file. A 1632 simple forward reference (TYPE_CODE_UNDEF) is not an 1633 empty structured type, though; the forward references 1634 work themselves out via the magic of coff_lookup_type. */ 1635 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR && 1636 TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 && 1637 TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) != 1638 TYPE_CODE_UNDEF) 1639 { 1640 int i = hashname (SYMBOL_LINKAGE_NAME (sym)); 1641 1642 SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i]; 1643 opaque_type_chain[i] = sym; 1644 } 1645 add_symbol_to_list (sym, &file_symbols); 1646 break; 1647 1648 case C_STRTAG: 1649 case C_UNTAG: 1650 case C_ENTAG: 1651 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 1652 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; 1653 1654 /* Some compilers try to be helpful by inventing "fake" 1655 names for anonymous enums, structures, and unions, like 1656 "~0fake" or ".0fake". Thanks, but no thanks... */ 1657 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0) 1658 if (SYMBOL_LINKAGE_NAME (sym) != NULL 1659 && *SYMBOL_LINKAGE_NAME (sym) != '~' 1660 && *SYMBOL_LINKAGE_NAME (sym) != '.') 1661 TYPE_TAG_NAME (SYMBOL_TYPE (sym)) = 1662 concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL); 1663 1664 add_symbol_to_list (sym, &file_symbols); 1665 break; 1666 1667 default: 1668 break; 1669 } 1670 } 1671 return sym; 1672 } 1673 1674 /* Decode a coff type specifier; return the type that is meant. */ 1675 1676 static struct type * 1677 decode_type (struct coff_symbol *cs, unsigned int c_type, 1678 union internal_auxent *aux, struct objfile *objfile) 1679 { 1680 struct type *type = 0; 1681 unsigned int new_c_type; 1682 1683 if (c_type & ~N_BTMASK) 1684 { 1685 new_c_type = DECREF (c_type); 1686 if (ISPTR (c_type)) 1687 { 1688 type = decode_type (cs, new_c_type, aux, objfile); 1689 type = lookup_pointer_type (type); 1690 } 1691 else if (ISFCN (c_type)) 1692 { 1693 type = decode_type (cs, new_c_type, aux, objfile); 1694 type = lookup_function_type (type); 1695 } 1696 else if (ISARY (c_type)) 1697 { 1698 int i, n; 1699 unsigned short *dim; 1700 struct type *base_type, *index_type, *range_type; 1701 1702 /* Define an array type. */ 1703 /* auxent refers to array, not base type */ 1704 if (aux->x_sym.x_tagndx.l == 0) 1705 cs->c_naux = 0; 1706 1707 /* shift the indices down */ 1708 dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0]; 1709 i = 1; 1710 n = dim[0]; 1711 for (i = 0; *dim && i < DIMNUM - 1; i++, dim++) 1712 *dim = *(dim + 1); 1713 *dim = 0; 1714 1715 base_type = decode_type (cs, new_c_type, aux, objfile); 1716 index_type = objfile_type (objfile)->builtin_int; 1717 range_type = 1718 create_range_type ((struct type *) NULL, index_type, 0, n - 1); 1719 type = 1720 create_array_type ((struct type *) NULL, base_type, range_type); 1721 } 1722 return type; 1723 } 1724 1725 /* Reference to existing type. This only occurs with the 1726 struct, union, and enum types. EPI a29k coff 1727 fakes us out by producing aux entries with a nonzero 1728 x_tagndx for definitions of structs, unions, and enums, so we 1729 have to check the c_sclass field. SCO 3.2v4 cc gets confused 1730 with pointers to pointers to defined structs, and generates 1731 negative x_tagndx fields. */ 1732 if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0) 1733 { 1734 if (cs->c_sclass != C_STRTAG 1735 && cs->c_sclass != C_UNTAG 1736 && cs->c_sclass != C_ENTAG 1737 && aux->x_sym.x_tagndx.l >= 0) 1738 { 1739 type = coff_alloc_type (aux->x_sym.x_tagndx.l); 1740 return type; 1741 } 1742 else 1743 { 1744 complaint (&symfile_complaints, 1745 _("Symbol table entry for %s has bad tagndx value"), 1746 cs->c_name); 1747 /* And fall through to decode_base_type... */ 1748 } 1749 } 1750 1751 return decode_base_type (cs, BTYPE (c_type), aux, objfile); 1752 } 1753 1754 /* Decode a coff type specifier for function definition; 1755 return the type that the function returns. */ 1756 1757 static struct type * 1758 decode_function_type (struct coff_symbol *cs, unsigned int c_type, 1759 union internal_auxent *aux, struct objfile *objfile) 1760 { 1761 if (aux->x_sym.x_tagndx.l == 0) 1762 cs->c_naux = 0; /* auxent refers to function, not base type */ 1763 1764 return decode_type (cs, DECREF (c_type), aux, objfile); 1765 } 1766 1767 /* basic C types */ 1768 1769 static struct type * 1770 decode_base_type (struct coff_symbol *cs, unsigned int c_type, 1771 union internal_auxent *aux, struct objfile *objfile) 1772 { 1773 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1774 struct type *type; 1775 1776 switch (c_type) 1777 { 1778 case T_NULL: 1779 /* shows up with "void (*foo)();" structure members */ 1780 return objfile_type (objfile)->builtin_void; 1781 1782 #ifdef T_VOID 1783 case T_VOID: 1784 /* Intel 960 COFF has this symbol and meaning. */ 1785 return objfile_type (objfile)->builtin_void; 1786 #endif 1787 1788 case T_CHAR: 1789 return objfile_type (objfile)->builtin_char; 1790 1791 case T_SHORT: 1792 return objfile_type (objfile)->builtin_short; 1793 1794 case T_INT: 1795 return objfile_type (objfile)->builtin_int; 1796 1797 case T_LONG: 1798 if (cs->c_sclass == C_FIELD 1799 && aux->x_sym.x_misc.x_lnsz.x_size 1800 > gdbarch_long_bit (gdbarch)) 1801 return objfile_type (objfile)->builtin_long_long; 1802 else 1803 return objfile_type (objfile)->builtin_long; 1804 1805 case T_FLOAT: 1806 return objfile_type (objfile)->builtin_float; 1807 1808 case T_DOUBLE: 1809 return objfile_type (objfile)->builtin_double; 1810 1811 case T_LNGDBL: 1812 return objfile_type (objfile)->builtin_long_double; 1813 1814 case T_STRUCT: 1815 if (cs->c_naux != 1) 1816 { 1817 /* anonymous structure type */ 1818 type = coff_alloc_type (cs->c_symnum); 1819 TYPE_CODE (type) = TYPE_CODE_STRUCT; 1820 TYPE_NAME (type) = NULL; 1821 /* This used to set the tag to "<opaque>". But I think setting it 1822 to NULL is right, and the printing code can print it as 1823 "struct {...}". */ 1824 TYPE_TAG_NAME (type) = NULL; 1825 INIT_CPLUS_SPECIFIC (type); 1826 TYPE_LENGTH (type) = 0; 1827 TYPE_FIELDS (type) = 0; 1828 TYPE_NFIELDS (type) = 0; 1829 } 1830 else 1831 { 1832 type = coff_read_struct_type (cs->c_symnum, 1833 aux->x_sym.x_misc.x_lnsz.x_size, 1834 aux->x_sym.x_fcnary.x_fcn.x_endndx.l, 1835 objfile); 1836 } 1837 return type; 1838 1839 case T_UNION: 1840 if (cs->c_naux != 1) 1841 { 1842 /* anonymous union type */ 1843 type = coff_alloc_type (cs->c_symnum); 1844 TYPE_NAME (type) = NULL; 1845 /* This used to set the tag to "<opaque>". But I think setting it 1846 to NULL is right, and the printing code can print it as 1847 "union {...}". */ 1848 TYPE_TAG_NAME (type) = NULL; 1849 INIT_CPLUS_SPECIFIC (type); 1850 TYPE_LENGTH (type) = 0; 1851 TYPE_FIELDS (type) = 0; 1852 TYPE_NFIELDS (type) = 0; 1853 } 1854 else 1855 { 1856 type = coff_read_struct_type (cs->c_symnum, 1857 aux->x_sym.x_misc.x_lnsz.x_size, 1858 aux->x_sym.x_fcnary.x_fcn.x_endndx.l, 1859 objfile); 1860 } 1861 TYPE_CODE (type) = TYPE_CODE_UNION; 1862 return type; 1863 1864 case T_ENUM: 1865 if (cs->c_naux != 1) 1866 { 1867 /* anonymous enum type */ 1868 type = coff_alloc_type (cs->c_symnum); 1869 TYPE_CODE (type) = TYPE_CODE_ENUM; 1870 TYPE_NAME (type) = NULL; 1871 /* This used to set the tag to "<opaque>". But I think setting it 1872 to NULL is right, and the printing code can print it as 1873 "enum {...}". */ 1874 TYPE_TAG_NAME (type) = NULL; 1875 TYPE_LENGTH (type) = 0; 1876 TYPE_FIELDS (type) = 0; 1877 TYPE_NFIELDS (type) = 0; 1878 } 1879 else 1880 { 1881 type = coff_read_enum_type (cs->c_symnum, 1882 aux->x_sym.x_misc.x_lnsz.x_size, 1883 aux->x_sym.x_fcnary.x_fcn.x_endndx.l, 1884 objfile); 1885 } 1886 return type; 1887 1888 case T_MOE: 1889 /* shouldn't show up here */ 1890 break; 1891 1892 case T_UCHAR: 1893 return objfile_type (objfile)->builtin_unsigned_char; 1894 1895 case T_USHORT: 1896 return objfile_type (objfile)->builtin_unsigned_short; 1897 1898 case T_UINT: 1899 return objfile_type (objfile)->builtin_unsigned_int; 1900 1901 case T_ULONG: 1902 if (cs->c_sclass == C_FIELD 1903 && aux->x_sym.x_misc.x_lnsz.x_size 1904 > gdbarch_long_bit (gdbarch)) 1905 return objfile_type (objfile)->builtin_unsigned_long_long; 1906 else 1907 return objfile_type (objfile)->builtin_unsigned_long; 1908 } 1909 complaint (&symfile_complaints, _("Unexpected type for symbol %s"), cs->c_name); 1910 return objfile_type (objfile)->builtin_void; 1911 } 1912 1913 /* This page contains subroutines of read_type. */ 1914 1915 /* Read the description of a structure (or union type) and return an 1916 object describing the type. */ 1917 1918 static struct type * 1919 coff_read_struct_type (int index, int length, int lastsym, 1920 struct objfile *objfile) 1921 { 1922 struct nextfield 1923 { 1924 struct nextfield *next; 1925 struct field field; 1926 }; 1927 1928 struct type *type; 1929 struct nextfield *list = 0; 1930 struct nextfield *new; 1931 int nfields = 0; 1932 int n; 1933 char *name; 1934 struct coff_symbol member_sym; 1935 struct coff_symbol *ms = &member_sym; 1936 struct internal_syment sub_sym; 1937 union internal_auxent sub_aux; 1938 int done = 0; 1939 1940 type = coff_alloc_type (index); 1941 TYPE_CODE (type) = TYPE_CODE_STRUCT; 1942 INIT_CPLUS_SPECIFIC (type); 1943 TYPE_LENGTH (type) = length; 1944 1945 while (!done && symnum < lastsym && symnum < nlist_nsyms_global) 1946 { 1947 read_one_sym (ms, &sub_sym, &sub_aux); 1948 name = ms->c_name; 1949 name = EXTERNAL_NAME (name, objfile->obfd); 1950 1951 switch (ms->c_sclass) 1952 { 1953 case C_MOS: 1954 case C_MOU: 1955 1956 /* Get space to record the next field's data. */ 1957 new = (struct nextfield *) alloca (sizeof (struct nextfield)); 1958 new->next = list; 1959 list = new; 1960 1961 /* Save the data. */ 1962 list->field.name = 1963 obsavestring (name, strlen (name), &objfile->objfile_obstack); 1964 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, 1965 objfile); 1966 SET_FIELD_BITPOS (list->field, 8 * ms->c_value); 1967 FIELD_BITSIZE (list->field) = 0; 1968 nfields++; 1969 break; 1970 1971 case C_FIELD: 1972 1973 /* Get space to record the next field's data. */ 1974 new = (struct nextfield *) alloca (sizeof (struct nextfield)); 1975 new->next = list; 1976 list = new; 1977 1978 /* Save the data. */ 1979 list->field.name = 1980 obsavestring (name, strlen (name), &objfile->objfile_obstack); 1981 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type, &sub_aux, 1982 objfile); 1983 SET_FIELD_BITPOS (list->field, ms->c_value); 1984 FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size; 1985 nfields++; 1986 break; 1987 1988 case C_EOS: 1989 done = 1; 1990 break; 1991 } 1992 } 1993 /* Now create the vector of fields, and record how big it is. */ 1994 1995 TYPE_NFIELDS (type) = nfields; 1996 TYPE_FIELDS (type) = (struct field *) 1997 TYPE_ALLOC (type, sizeof (struct field) * nfields); 1998 1999 /* Copy the saved-up fields into the field vector. */ 2000 2001 for (n = nfields; list; list = list->next) 2002 TYPE_FIELD (type, --n) = list->field; 2003 2004 return type; 2005 } 2006 2007 /* Read a definition of an enumeration type, 2008 and create and return a suitable type object. 2009 Also defines the symbols that represent the values of the type. */ 2010 2011 static struct type * 2012 coff_read_enum_type (int index, int length, int lastsym, 2013 struct objfile *objfile) 2014 { 2015 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2016 struct symbol *sym; 2017 struct type *type; 2018 int nsyms = 0; 2019 int done = 0; 2020 struct pending **symlist; 2021 struct coff_symbol member_sym; 2022 struct coff_symbol *ms = &member_sym; 2023 struct internal_syment sub_sym; 2024 union internal_auxent sub_aux; 2025 struct pending *osyms, *syms; 2026 int o_nsyms; 2027 int n; 2028 char *name; 2029 int unsigned_enum = 1; 2030 2031 type = coff_alloc_type (index); 2032 if (within_function) 2033 symlist = &local_symbols; 2034 else 2035 symlist = &file_symbols; 2036 osyms = *symlist; 2037 o_nsyms = osyms ? osyms->nsyms : 0; 2038 2039 while (!done && symnum < lastsym && symnum < nlist_nsyms_global) 2040 { 2041 read_one_sym (ms, &sub_sym, &sub_aux); 2042 name = ms->c_name; 2043 name = EXTERNAL_NAME (name, objfile->obfd); 2044 2045 switch (ms->c_sclass) 2046 { 2047 case C_MOE: 2048 sym = (struct symbol *) obstack_alloc 2049 (&objfile->objfile_obstack, sizeof (struct symbol)); 2050 memset (sym, 0, sizeof (struct symbol)); 2051 2052 SYMBOL_SET_LINKAGE_NAME (sym, 2053 obsavestring (name, strlen (name), 2054 &objfile->objfile_obstack)); 2055 SYMBOL_CLASS (sym) = LOC_CONST; 2056 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 2057 SYMBOL_VALUE (sym) = ms->c_value; 2058 add_symbol_to_list (sym, symlist); 2059 nsyms++; 2060 break; 2061 2062 case C_EOS: 2063 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws 2064 up the count of how many symbols to read. So stop 2065 on .eos. */ 2066 done = 1; 2067 break; 2068 } 2069 } 2070 2071 /* Now fill in the fields of the type-structure. */ 2072 2073 if (length > 0) 2074 TYPE_LENGTH (type) = length; 2075 else /* Assume ints. */ 2076 TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT; 2077 TYPE_CODE (type) = TYPE_CODE_ENUM; 2078 TYPE_NFIELDS (type) = nsyms; 2079 TYPE_FIELDS (type) = (struct field *) 2080 TYPE_ALLOC (type, sizeof (struct field) * nsyms); 2081 2082 /* Find the symbols for the values and put them into the type. 2083 The symbols can be found in the symlist that we put them on 2084 to cause them to be defined. osyms contains the old value 2085 of that symlist; everything up to there was defined by us. */ 2086 /* Note that we preserve the order of the enum constants, so 2087 that in something like "enum {FOO, LAST_THING=FOO}" we print 2088 FOO, not LAST_THING. */ 2089 2090 for (syms = *symlist, n = 0; syms; syms = syms->next) 2091 { 2092 int j = 0; 2093 2094 if (syms == osyms) 2095 j = o_nsyms; 2096 for (; j < syms->nsyms; j++, n++) 2097 { 2098 struct symbol *xsym = syms->symbol[j]; 2099 SYMBOL_TYPE (xsym) = type; 2100 TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym); 2101 SET_FIELD_BITPOS (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym)); 2102 if (SYMBOL_VALUE (xsym) < 0) 2103 unsigned_enum = 0; 2104 TYPE_FIELD_BITSIZE (type, n) = 0; 2105 } 2106 if (syms == osyms) 2107 break; 2108 } 2109 2110 if (unsigned_enum) 2111 TYPE_UNSIGNED (type) = 1; 2112 2113 return type; 2114 } 2115 2116 /* Register our ability to parse symbols for coff BFD files. */ 2117 2118 static struct sym_fns coff_sym_fns = 2119 { 2120 bfd_target_coff_flavour, 2121 coff_new_init, /* sym_new_init: init anything gbl to entire symtab */ 2122 coff_symfile_init, /* sym_init: read initial info, setup for sym_read() */ 2123 coff_symfile_read, /* sym_read: read a symbol file into symtab */ 2124 coff_symfile_finish, /* sym_finish: finished with file, cleanup */ 2125 default_symfile_offsets, /* sym_offsets: xlate external to internal form */ 2126 default_symfile_segments, /* sym_segments: Get segment information from 2127 a file. */ 2128 NULL, /* sym_read_linetable */ 2129 NULL /* next: pointer to next struct sym_fns */ 2130 }; 2131 2132 void 2133 _initialize_coffread (void) 2134 { 2135 add_symtab_fns (&coff_sym_fns); 2136 } 2137