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