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