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