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