1 /* Read a symbol table in ECOFF format (Third-Eye). 2 3 Copyright (C) 1986, 1987, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008, 2009 5 Free Software Foundation, Inc. 6 7 Original version contributed by Alessandro Forin (af@cs.cmu.edu) at 8 CMU. Major work by Per Bothner, John Gilmore and Ian Lance Taylor 9 at Cygnus Support. 10 11 This file is part of GDB. 12 13 This program is free software; you can redistribute it and/or modify 14 it under the terms of the GNU General Public License as published by 15 the Free Software Foundation; either version 3 of the License, or 16 (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, 19 but WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 21 GNU General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 25 26 /* This module provides the function mdebug_build_psymtabs. It reads 27 ECOFF debugging information into partial symbol tables. The 28 debugging information is read from two structures. A struct 29 ecoff_debug_swap includes the sizes of each ECOFF structure and 30 swapping routines; these are fixed for a particular target. A 31 struct ecoff_debug_info points to the debugging information for a 32 particular object file. 33 34 ECOFF symbol tables are mostly written in the byte order of the 35 target machine. However, one section of the table (the auxiliary 36 symbol information) is written in the host byte order. There is a 37 bit in the other symbol info which describes which host byte order 38 was used. ECOFF thereby takes the trophy from Intel `b.out' for 39 the most brain-dead adaptation of a file format to byte order. 40 41 This module can read all four of the known byte-order combinations, 42 on any type of host. */ 43 44 #include "defs.h" 45 #include "symtab.h" 46 #include "gdbtypes.h" 47 #include "gdbcore.h" 48 #include "objfiles.h" 49 #include "gdb_obstack.h" 50 #include "buildsym.h" 51 #include "stabsread.h" 52 #include "complaints.h" 53 #include "demangle.h" 54 #include "gdb_assert.h" 55 #include "block.h" 56 #include "dictionary.h" 57 #include "mdebugread.h" 58 #include "gdb_stat.h" 59 #include "gdb_string.h" 60 61 #include "bfd.h" 62 63 #include "coff/ecoff.h" /* COFF-like aspects of ecoff files */ 64 65 #include "libaout.h" /* Private BFD a.out information. */ 66 #include "aout/aout64.h" 67 #include "aout/stab_gnu.h" /* STABS information */ 68 69 #include "expression.h" 70 71 extern void _initialize_mdebugread (void); 72 73 /* Provide a way to test if we have both ECOFF and ELF symbol tables. 74 We use this define in order to know whether we should override a 75 symbol's ECOFF section with its ELF section. This is necessary in 76 case the symbol's ELF section could not be represented in ECOFF. */ 77 #define ECOFF_IN_ELF(bfd) (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 78 && bfd_get_section_by_name (bfd, ".mdebug") != NULL) 79 80 81 /* We put a pointer to this structure in the read_symtab_private field 82 of the psymtab. */ 83 84 struct symloc 85 { 86 /* Index of the FDR that this psymtab represents. */ 87 int fdr_idx; 88 /* The BFD that the psymtab was created from. */ 89 bfd *cur_bfd; 90 const struct ecoff_debug_swap *debug_swap; 91 struct ecoff_debug_info *debug_info; 92 struct mdebug_pending **pending_list; 93 /* Pointer to external symbols for this file. */ 94 EXTR *extern_tab; 95 /* Size of extern_tab. */ 96 int extern_count; 97 enum language pst_language; 98 }; 99 100 #define PST_PRIVATE(p) ((struct symloc *)(p)->read_symtab_private) 101 #define FDR_IDX(p) (PST_PRIVATE(p)->fdr_idx) 102 #define CUR_BFD(p) (PST_PRIVATE(p)->cur_bfd) 103 #define DEBUG_SWAP(p) (PST_PRIVATE(p)->debug_swap) 104 #define DEBUG_INFO(p) (PST_PRIVATE(p)->debug_info) 105 #define PENDING_LIST(p) (PST_PRIVATE(p)->pending_list) 106 107 #define SC_IS_TEXT(sc) ((sc) == scText \ 108 || (sc) == scRConst \ 109 || (sc) == scInit \ 110 || (sc) == scFini) 111 #define SC_IS_DATA(sc) ((sc) == scData \ 112 || (sc) == scSData \ 113 || (sc) == scRData \ 114 || (sc) == scPData \ 115 || (sc) == scXData) 116 #define SC_IS_COMMON(sc) ((sc) == scCommon || (sc) == scSCommon) 117 #define SC_IS_BSS(sc) ((sc) == scBss) 118 #define SC_IS_SBSS(sc) ((sc) == scSBss) 119 #define SC_IS_UNDEF(sc) ((sc) == scUndefined || (sc) == scSUndefined) 120 121 /* Various complaints about symbol reading that don't abort the process */ 122 static void 123 index_complaint (const char *arg1) 124 { 125 complaint (&symfile_complaints, _("bad aux index at symbol %s"), arg1); 126 } 127 128 static void 129 unknown_ext_complaint (const char *arg1) 130 { 131 complaint (&symfile_complaints, _("unknown external symbol %s"), arg1); 132 } 133 134 static void 135 basic_type_complaint (int arg1, const char *arg2) 136 { 137 complaint (&symfile_complaints, _("cannot map ECOFF basic type 0x%x for %s"), 138 arg1, arg2); 139 } 140 141 static void 142 bad_tag_guess_complaint (const char *arg1) 143 { 144 complaint (&symfile_complaints, _("guessed tag type of %s incorrectly"), arg1); 145 } 146 147 static void 148 bad_rfd_entry_complaint (const char *arg1, int arg2, int arg3) 149 { 150 complaint (&symfile_complaints, _("bad rfd entry for %s: file %d, index %d"), 151 arg1, arg2, arg3); 152 } 153 154 static void 155 unexpected_type_code_complaint (const char *arg1) 156 { 157 complaint (&symfile_complaints, _("unexpected type code for %s"), arg1); 158 } 159 160 /* Macros and extra defs */ 161 162 /* Puns: hard to find whether -g was used and how */ 163 164 #define MIN_GLEVEL GLEVEL_0 165 #define compare_glevel(a,b) \ 166 (((a) == GLEVEL_3) ? ((b) < GLEVEL_3) : \ 167 ((b) == GLEVEL_3) ? -1 : (int)((b) - (a))) 168 169 /* Things that really are local to this module */ 170 171 /* Remember what we deduced to be the source language of this psymtab. */ 172 173 static enum language psymtab_language = language_unknown; 174 175 /* Current BFD. */ 176 177 static bfd *cur_bfd; 178 179 /* How to parse debugging information for CUR_BFD. */ 180 181 static const struct ecoff_debug_swap *debug_swap; 182 183 /* Pointers to debugging information for CUR_BFD. */ 184 185 static struct ecoff_debug_info *debug_info; 186 187 /* Pointer to current file decriptor record, and its index */ 188 189 static FDR *cur_fdr; 190 static int cur_fd; 191 192 /* Index of current symbol */ 193 194 static int cur_sdx; 195 196 /* Note how much "debuggable" this image is. We would like 197 to see at least one FDR with full symbols */ 198 199 static int max_gdbinfo; 200 static int max_glevel; 201 202 /* When examining .o files, report on undefined symbols */ 203 204 static int n_undef_symbols, n_undef_labels, n_undef_vars, n_undef_procs; 205 206 /* Pseudo symbol to use when putting stabs into the symbol table. */ 207 208 static char stabs_symbol[] = STABS_SYMBOL; 209 210 /* Nonzero if we have seen ecoff debugging info for a file. */ 211 212 static int found_ecoff_debugging_info; 213 214 /* Forward declarations */ 215 216 static int upgrade_type (int, struct type **, int, union aux_ext *, 217 int, char *); 218 219 static void parse_partial_symbols (struct objfile *); 220 221 static int has_opaque_xref (FDR *, SYMR *); 222 223 static int cross_ref (int, union aux_ext *, struct type **, enum type_code, 224 char **, int, char *); 225 226 static struct symbol *new_symbol (char *); 227 228 static struct type *new_type (char *); 229 230 enum block_type { FUNCTION_BLOCK, NON_FUNCTION_BLOCK }; 231 232 static struct block *new_block (enum block_type); 233 234 static struct symtab *new_symtab (char *, int, struct objfile *); 235 236 static struct linetable *new_linetable (int); 237 238 static struct blockvector *new_bvect (int); 239 240 static struct type *parse_type (int, union aux_ext *, unsigned int, int *, 241 int, char *); 242 243 static struct symbol *mylookup_symbol (char *, struct block *, domain_enum, 244 enum address_class); 245 246 static void sort_blocks (struct symtab *); 247 248 static struct partial_symtab *new_psymtab (char *, struct objfile *); 249 250 static void psymtab_to_symtab_1 (struct partial_symtab *, char *); 251 252 static void add_block (struct block *, struct symtab *); 253 254 static void add_symbol (struct symbol *, struct symtab *, struct block *); 255 256 static int add_line (struct linetable *, int, CORE_ADDR, int); 257 258 static struct linetable *shrink_linetable (struct linetable *); 259 260 static void handle_psymbol_enumerators (struct objfile *, FDR *, int, 261 CORE_ADDR); 262 263 static char *mdebug_next_symbol_text (struct objfile *); 264 265 /* Exported procedure: Builds a symtab from the PST partial one. 266 Restores the environment in effect when PST was created, delegates 267 most of the work to an ancillary procedure, and sorts 268 and reorders the symtab list at the end */ 269 270 static void 271 mdebug_psymtab_to_symtab (struct partial_symtab *pst) 272 { 273 274 if (!pst) 275 return; 276 277 if (info_verbose) 278 { 279 printf_filtered (_("Reading in symbols for %s..."), pst->filename); 280 gdb_flush (gdb_stdout); 281 } 282 283 next_symbol_text_func = mdebug_next_symbol_text; 284 285 psymtab_to_symtab_1 (pst, pst->filename); 286 287 /* Match with global symbols. This only needs to be done once, 288 after all of the symtabs and dependencies have been read in. */ 289 scan_file_globals (pst->objfile); 290 291 if (info_verbose) 292 printf_filtered (_("done.\n")); 293 } 294 295 /* File-level interface functions */ 296 297 /* Find a file descriptor given its index RF relative to a file CF */ 298 299 static FDR * 300 get_rfd (int cf, int rf) 301 { 302 FDR *fdrs; 303 FDR *f; 304 RFDT rfd; 305 306 fdrs = debug_info->fdr; 307 f = fdrs + cf; 308 /* Object files do not have the RFD table, all refs are absolute */ 309 if (f->rfdBase == 0) 310 return fdrs + rf; 311 (*debug_swap->swap_rfd_in) (cur_bfd, 312 ((char *) debug_info->external_rfd 313 + ((f->rfdBase + rf) 314 * debug_swap->external_rfd_size)), 315 &rfd); 316 return fdrs + rfd; 317 } 318 319 /* Return a safer print NAME for a file descriptor */ 320 321 static char * 322 fdr_name (FDR *f) 323 { 324 if (f->rss == -1) 325 return "<stripped file>"; 326 if (f->rss == 0) 327 return "<NFY>"; 328 return debug_info->ss + f->issBase + f->rss; 329 } 330 331 332 /* Read in and parse the symtab of the file OBJFILE. Symbols from 333 different sections are relocated via the SECTION_OFFSETS. */ 334 335 void 336 mdebug_build_psymtabs (struct objfile *objfile, 337 const struct ecoff_debug_swap *swap, 338 struct ecoff_debug_info *info) 339 { 340 cur_bfd = objfile->obfd; 341 debug_swap = swap; 342 debug_info = info; 343 344 stabsread_new_init (); 345 buildsym_new_init (); 346 free_header_files (); 347 init_header_files (); 348 349 /* Make sure all the FDR information is swapped in. */ 350 if (info->fdr == (FDR *) NULL) 351 { 352 char *fdr_src; 353 char *fdr_end; 354 FDR *fdr_ptr; 355 356 info->fdr = (FDR *) obstack_alloc (&objfile->objfile_obstack, 357 (info->symbolic_header.ifdMax 358 * sizeof (FDR))); 359 fdr_src = info->external_fdr; 360 fdr_end = (fdr_src 361 + info->symbolic_header.ifdMax * swap->external_fdr_size); 362 fdr_ptr = info->fdr; 363 for (; fdr_src < fdr_end; fdr_src += swap->external_fdr_size, fdr_ptr++) 364 (*swap->swap_fdr_in) (objfile->obfd, fdr_src, fdr_ptr); 365 } 366 367 parse_partial_symbols (objfile); 368 369 #if 0 370 /* Check to make sure file was compiled with -g. If not, warn the 371 user of this limitation. */ 372 if (compare_glevel (max_glevel, GLEVEL_2) < 0) 373 { 374 if (max_gdbinfo == 0) 375 printf_unfiltered (_("\n%s not compiled with -g, debugging support is limited.\n"), 376 objfile->name); 377 printf_unfiltered (_("You should compile with -g2 or -g3 for best debugging support.\n")); 378 gdb_flush (gdb_stdout); 379 } 380 #endif 381 } 382 383 /* Local utilities */ 384 385 /* Map of FDR indexes to partial symtabs */ 386 387 struct pst_map 388 { 389 struct partial_symtab *pst; /* the psymtab proper */ 390 long n_globals; /* exported globals (external symbols) */ 391 long globals_offset; /* cumulative */ 392 }; 393 394 395 /* Utility stack, used to nest procedures and blocks properly. 396 It is a doubly linked list, to avoid too many alloc/free. 397 Since we might need it quite a few times it is NOT deallocated 398 after use. */ 399 400 static struct parse_stack 401 { 402 struct parse_stack *next, *prev; 403 struct symtab *cur_st; /* Current symtab. */ 404 struct block *cur_block; /* Block in it. */ 405 406 /* What are we parsing. stFile, or stBlock are for files and 407 blocks. stProc or stStaticProc means we have seen the start of a 408 procedure, but not the start of the block within in. When we see 409 the start of that block, we change it to stNil, without pushing a 410 new block, i.e. stNil means both a procedure and a block. */ 411 412 int blocktype; 413 414 struct type *cur_type; /* Type we parse fields for. */ 415 int cur_field; /* Field number in cur_type. */ 416 CORE_ADDR procadr; /* Start addres of this procedure */ 417 int numargs; /* Its argument count */ 418 } 419 420 *top_stack; /* Top stack ptr */ 421 422 423 /* Enter a new lexical context */ 424 425 static void 426 push_parse_stack (void) 427 { 428 struct parse_stack *new; 429 430 /* Reuse frames if possible */ 431 if (top_stack && top_stack->prev) 432 new = top_stack->prev; 433 else 434 new = (struct parse_stack *) xzalloc (sizeof (struct parse_stack)); 435 /* Initialize new frame with previous content */ 436 if (top_stack) 437 { 438 struct parse_stack *prev = new->prev; 439 440 *new = *top_stack; 441 top_stack->prev = new; 442 new->prev = prev; 443 new->next = top_stack; 444 } 445 top_stack = new; 446 } 447 448 /* Exit a lexical context */ 449 450 static void 451 pop_parse_stack (void) 452 { 453 if (!top_stack) 454 return; 455 if (top_stack->next) 456 top_stack = top_stack->next; 457 } 458 459 460 /* Cross-references might be to things we haven't looked at 461 yet, e.g. type references. To avoid too many type 462 duplications we keep a quick fixup table, an array 463 of lists of references indexed by file descriptor */ 464 465 struct mdebug_pending 466 { 467 struct mdebug_pending *next; /* link */ 468 char *s; /* the unswapped symbol */ 469 struct type *t; /* its partial type descriptor */ 470 }; 471 472 473 /* The pending information is kept for an entire object file, and used 474 to be in the deprecated_sym_private field. I took it out when I 475 split mdebugread from mipsread, because this might not be the only 476 type of symbols read from an object file. Instead, we allocate the 477 pending information table when we create the partial symbols, and 478 we store a pointer to the single table in each psymtab. */ 479 480 static struct mdebug_pending **pending_list; 481 482 /* Check whether we already saw symbol SH in file FH */ 483 484 static struct mdebug_pending * 485 is_pending_symbol (FDR *fh, char *sh) 486 { 487 int f_idx = fh - debug_info->fdr; 488 struct mdebug_pending *p; 489 490 /* Linear search is ok, list is typically no more than 10 deep */ 491 for (p = pending_list[f_idx]; p; p = p->next) 492 if (p->s == sh) 493 break; 494 return p; 495 } 496 497 /* Add a new symbol SH of type T */ 498 499 static void 500 add_pending (FDR *fh, char *sh, struct type *t) 501 { 502 int f_idx = fh - debug_info->fdr; 503 struct mdebug_pending *p = is_pending_symbol (fh, sh); 504 505 /* Make sure we do not make duplicates */ 506 if (!p) 507 { 508 p = ((struct mdebug_pending *) 509 obstack_alloc (¤t_objfile->objfile_obstack, 510 sizeof (struct mdebug_pending))); 511 p->s = sh; 512 p->t = t; 513 p->next = pending_list[f_idx]; 514 pending_list[f_idx] = p; 515 } 516 } 517 518 519 /* Parsing Routines proper. */ 520 521 /* Parse a single symbol. Mostly just make up a GDB symbol for it. 522 For blocks, procedures and types we open a new lexical context. 523 This is basically just a big switch on the symbol's type. Argument 524 AX is the base pointer of aux symbols for this file (fh->iauxBase). 525 EXT_SH points to the unswapped symbol, which is needed for struct, 526 union, etc., types; it is NULL for an EXTR. BIGEND says whether 527 aux symbols are big-endian or little-endian. Return count of 528 SYMR's handled (normally one). */ 529 530 static int 531 mdebug_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) 532 { 533 return gdbarch_ecoff_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); 534 } 535 536 static const struct symbol_register_ops mdebug_register_funcs = { 537 mdebug_reg_to_regnum 538 }; 539 540 static int 541 parse_symbol (SYMR *sh, union aux_ext *ax, char *ext_sh, int bigend, 542 struct section_offsets *section_offsets, struct objfile *objfile) 543 { 544 struct gdbarch *gdbarch = get_objfile_arch (objfile); 545 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 546 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 547 char *name; 548 struct symbol *s; 549 struct block *b; 550 struct mdebug_pending *pend; 551 struct type *t; 552 struct field *f; 553 int count = 1; 554 enum address_class class; 555 TIR tir; 556 long svalue = sh->value; 557 int bitsize; 558 559 if (ext_sh == (char *) NULL) 560 name = debug_info->ssext + sh->iss; 561 else 562 name = debug_info->ss + cur_fdr->issBase + sh->iss; 563 564 switch (sh->sc) 565 { 566 case scText: 567 case scRConst: 568 /* Do not relocate relative values. 569 The value of a stEnd symbol is the displacement from the 570 corresponding start symbol value. 571 The value of a stBlock symbol is the displacement from the 572 procedure address. */ 573 if (sh->st != stEnd && sh->st != stBlock) 574 sh->value += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)); 575 break; 576 case scData: 577 case scSData: 578 case scRData: 579 case scPData: 580 case scXData: 581 sh->value += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile)); 582 break; 583 case scBss: 584 case scSBss: 585 sh->value += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile)); 586 break; 587 } 588 589 switch (sh->st) 590 { 591 case stNil: 592 break; 593 594 case stGlobal: /* external symbol, goes into global block */ 595 class = LOC_STATIC; 596 b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), 597 GLOBAL_BLOCK); 598 s = new_symbol (name); 599 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 600 goto data; 601 602 case stStatic: /* static data, goes into current block. */ 603 class = LOC_STATIC; 604 b = top_stack->cur_block; 605 s = new_symbol (name); 606 if (SC_IS_COMMON (sh->sc)) 607 { 608 /* It is a FORTRAN common block. At least for SGI Fortran the 609 address is not in the symbol; we need to fix it later in 610 scan_file_globals. */ 611 int bucket = hashname (SYMBOL_LINKAGE_NAME (s)); 612 SYMBOL_VALUE_CHAIN (s) = global_sym_chain[bucket]; 613 global_sym_chain[bucket] = s; 614 } 615 else 616 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 617 goto data; 618 619 case stLocal: /* local variable, goes into current block */ 620 b = top_stack->cur_block; 621 s = new_symbol (name); 622 SYMBOL_VALUE (s) = svalue; 623 if (sh->sc == scRegister) 624 { 625 class = LOC_REGISTER; 626 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 627 } 628 else 629 class = LOC_LOCAL; 630 631 data: /* Common code for symbols describing data */ 632 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 633 SYMBOL_CLASS (s) = class; 634 add_symbol (s, top_stack->cur_st, b); 635 636 /* Type could be missing if file is compiled without debugging info. */ 637 if (SC_IS_UNDEF (sh->sc) 638 || sh->sc == scNil || sh->index == indexNil) 639 SYMBOL_TYPE (s) = objfile_type (objfile)->nodebug_data_symbol; 640 else 641 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); 642 /* Value of a data symbol is its memory address */ 643 break; 644 645 case stParam: /* arg to procedure, goes into current block */ 646 max_gdbinfo++; 647 found_ecoff_debugging_info = 1; 648 top_stack->numargs++; 649 650 /* Special GNU C++ name. */ 651 if (is_cplus_marker (name[0]) && name[1] == 't' && name[2] == 0) 652 name = "this"; /* FIXME, not alloc'd in obstack */ 653 s = new_symbol (name); 654 655 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 656 SYMBOL_IS_ARGUMENT (s) = 1; 657 switch (sh->sc) 658 { 659 case scRegister: 660 /* Pass by value in register. */ 661 SYMBOL_CLASS (s) = LOC_REGISTER; 662 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 663 break; 664 case scVar: 665 /* Pass by reference on stack. */ 666 SYMBOL_CLASS (s) = LOC_REF_ARG; 667 break; 668 case scVarRegister: 669 /* Pass by reference in register. */ 670 SYMBOL_CLASS (s) = LOC_REGPARM_ADDR; 671 SYMBOL_REGISTER_OPS (s) = &mdebug_register_funcs; 672 break; 673 default: 674 /* Pass by value on stack. */ 675 SYMBOL_CLASS (s) = LOC_ARG; 676 break; 677 } 678 SYMBOL_VALUE (s) = svalue; 679 SYMBOL_TYPE (s) = parse_type (cur_fd, ax, sh->index, 0, bigend, name); 680 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 681 break; 682 683 case stLabel: /* label, goes into current block */ 684 s = new_symbol (name); 685 SYMBOL_DOMAIN (s) = VAR_DOMAIN; /* so that it can be used */ 686 SYMBOL_CLASS (s) = LOC_LABEL; /* but not misused */ 687 SYMBOL_VALUE_ADDRESS (s) = (CORE_ADDR) sh->value; 688 SYMBOL_TYPE (s) = objfile_type (objfile)->builtin_int; 689 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 690 break; 691 692 case stProc: /* Procedure, usually goes into global block */ 693 case stStaticProc: /* Static procedure, goes into current block */ 694 /* For stProc symbol records, we need to check the storage class 695 as well, as only (stProc, scText) entries represent "real" 696 procedures - See the Compaq document titled "Object File / 697 Symbol Table Format Specification" for more information. 698 If the storage class is not scText, we discard the whole block 699 of symbol records for this stProc. */ 700 if (sh->st == stProc && sh->sc != scText) 701 { 702 char *ext_tsym = ext_sh; 703 int keep_counting = 1; 704 SYMR tsym; 705 706 while (keep_counting) 707 { 708 ext_tsym += external_sym_size; 709 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 710 count++; 711 switch (tsym.st) 712 { 713 case stParam: 714 break; 715 case stEnd: 716 keep_counting = 0; 717 break; 718 default: 719 complaint (&symfile_complaints, 720 _("unknown symbol type 0x%x"), sh->st); 721 break; 722 } 723 } 724 break; 725 } 726 s = new_symbol (name); 727 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 728 SYMBOL_CLASS (s) = LOC_BLOCK; 729 /* Type of the return value */ 730 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) 731 t = objfile_type (objfile)->builtin_int; 732 else 733 { 734 t = parse_type (cur_fd, ax, sh->index + 1, 0, bigend, name); 735 if (strcmp (name, "malloc") == 0 736 && TYPE_CODE (t) == TYPE_CODE_VOID) 737 { 738 /* I don't know why, but, at least under Alpha GNU/Linux, 739 when linking against a malloc without debugging 740 symbols, its read as a function returning void---this 741 is bad because it means we cannot call functions with 742 string arguments interactively; i.e., "call 743 printf("howdy\n")" would fail with the error message 744 "program has no memory available". To avoid this, we 745 patch up the type and make it void* 746 instead. (davidm@azstarnet.com) 747 */ 748 t = make_pointer_type (t, NULL); 749 } 750 } 751 b = top_stack->cur_block; 752 if (sh->st == stProc) 753 { 754 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); 755 /* The next test should normally be true, but provides a 756 hook for nested functions (which we don't want to make 757 global). */ 758 if (b == BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) 759 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 760 /* Irix 5 sometimes has duplicate names for the same 761 function. We want to add such names up at the global 762 level, not as a nested function. */ 763 else if (sh->value == top_stack->procadr) 764 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK); 765 } 766 add_symbol (s, top_stack->cur_st, b); 767 768 /* Make a type for the procedure itself */ 769 SYMBOL_TYPE (s) = lookup_function_type (t); 770 771 /* All functions in C++ have prototypes. For C we don't have enough 772 information in the debug info. */ 773 if (SYMBOL_LANGUAGE (s) == language_cplus) 774 TYPE_PROTOTYPED (SYMBOL_TYPE (s)) = 1; 775 776 /* Create and enter a new lexical context */ 777 b = new_block (FUNCTION_BLOCK); 778 SYMBOL_BLOCK_VALUE (s) = b; 779 BLOCK_FUNCTION (b) = s; 780 BLOCK_START (b) = BLOCK_END (b) = sh->value; 781 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 782 add_block (b, top_stack->cur_st); 783 784 /* Not if we only have partial info */ 785 if (SC_IS_UNDEF (sh->sc) || sh->sc == scNil) 786 break; 787 788 push_parse_stack (); 789 top_stack->cur_block = b; 790 top_stack->blocktype = sh->st; 791 top_stack->cur_type = SYMBOL_TYPE (s); 792 top_stack->cur_field = -1; 793 top_stack->procadr = sh->value; 794 top_stack->numargs = 0; 795 break; 796 797 /* Beginning of code for structure, union, and enum definitions. 798 They all share a common set of local variables, defined here. */ 799 { 800 enum type_code type_code; 801 char *ext_tsym; 802 int nfields; 803 long max_value; 804 struct field *f; 805 806 case stStruct: /* Start a block defining a struct type */ 807 type_code = TYPE_CODE_STRUCT; 808 goto structured_common; 809 810 case stUnion: /* Start a block defining a union type */ 811 type_code = TYPE_CODE_UNION; 812 goto structured_common; 813 814 case stEnum: /* Start a block defining an enum type */ 815 type_code = TYPE_CODE_ENUM; 816 goto structured_common; 817 818 case stBlock: /* Either a lexical block, or some type */ 819 if (sh->sc != scInfo && !SC_IS_COMMON (sh->sc)) 820 goto case_stBlock_code; /* Lexical block */ 821 822 type_code = TYPE_CODE_UNDEF; /* We have a type. */ 823 824 /* Common code for handling struct, union, enum, and/or as-yet- 825 unknown-type blocks of info about structured data. `type_code' 826 has been set to the proper TYPE_CODE, if we know it. */ 827 structured_common: 828 found_ecoff_debugging_info = 1; 829 push_parse_stack (); 830 top_stack->blocktype = stBlock; 831 832 /* First count the number of fields and the highest value. */ 833 nfields = 0; 834 max_value = 0; 835 for (ext_tsym = ext_sh + external_sym_size; 836 ; 837 ext_tsym += external_sym_size) 838 { 839 SYMR tsym; 840 841 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 842 843 switch (tsym.st) 844 { 845 case stEnd: 846 /* C++ encodes class types as structures where there the 847 methods are encoded as stProc. The scope of stProc 848 symbols also ends with stEnd, thus creating a risk of 849 taking the wrong stEnd symbol record as the end of 850 the current struct, which would cause GDB to undercount 851 the real number of fields in this struct. To make sure 852 we really reached the right stEnd symbol record, we 853 check the associated name, and match it against the 854 struct name. Since method names are mangled while 855 the class name is not, there is no risk of having a 856 method whose name is identical to the class name 857 (in particular constructor method names are different 858 from the class name). There is therefore no risk that 859 this check stops the count on the StEnd of a method. 860 861 Also, assume that we're really at the end when tsym.iss 862 is 0 (issNull). */ 863 if (tsym.iss == issNull 864 || strcmp (debug_info->ss + cur_fdr->issBase + tsym.iss, 865 name) == 0) 866 goto end_of_fields; 867 break; 868 869 case stMember: 870 if (nfields == 0 && type_code == TYPE_CODE_UNDEF) 871 { 872 /* If the type of the member is Nil (or Void), 873 without qualifiers, assume the tag is an 874 enumeration. 875 Alpha cc -migrate enums are recognized by a zero 876 index and a zero symbol value. 877 DU 4.0 cc enums are recognized by a member type of 878 btEnum without qualifiers and a zero symbol value. */ 879 if (tsym.index == indexNil 880 || (tsym.index == 0 && sh->value == 0)) 881 type_code = TYPE_CODE_ENUM; 882 else 883 { 884 (*debug_swap->swap_tir_in) (bigend, 885 &ax[tsym.index].a_ti, 886 &tir); 887 if ((tir.bt == btNil || tir.bt == btVoid 888 || (tir.bt == btEnum && sh->value == 0)) 889 && tir.tq0 == tqNil) 890 type_code = TYPE_CODE_ENUM; 891 } 892 } 893 nfields++; 894 if (tsym.value > max_value) 895 max_value = tsym.value; 896 break; 897 898 case stBlock: 899 case stUnion: 900 case stEnum: 901 case stStruct: 902 { 903 #if 0 904 /* This is a no-op; is it trying to tell us something 905 we should be checking? */ 906 if (tsym.sc == scVariant); /*UNIMPLEMENTED */ 907 #endif 908 if (tsym.index != 0) 909 { 910 /* This is something like a struct within a 911 struct. Skip over the fields of the inner 912 struct. The -1 is because the for loop will 913 increment ext_tsym. */ 914 ext_tsym = ((char *) debug_info->external_sym 915 + ((cur_fdr->isymBase + tsym.index - 1) 916 * external_sym_size)); 917 } 918 } 919 break; 920 921 case stTypedef: 922 /* mips cc puts out a typedef for struct x if it is not yet 923 defined when it encounters 924 struct y { struct x *xp; }; 925 Just ignore it. */ 926 break; 927 928 case stIndirect: 929 /* Irix5 cc puts out a stIndirect for struct x if it is not 930 yet defined when it encounters 931 struct y { struct x *xp; }; 932 Just ignore it. */ 933 break; 934 935 default: 936 complaint (&symfile_complaints, 937 _("declaration block contains unhandled symbol type %d"), 938 tsym.st); 939 } 940 } 941 end_of_fields:; 942 943 /* In an stBlock, there is no way to distinguish structs, 944 unions, and enums at this point. This is a bug in the 945 original design (that has been fixed with the recent 946 addition of the stStruct, stUnion, and stEnum symbol 947 types.) The way you can tell is if/when you see a variable 948 or field of that type. In that case the variable's type 949 (in the AUX table) says if the type is struct, union, or 950 enum, and points back to the stBlock here. So you can 951 patch the tag kind up later - but only if there actually is 952 a variable or field of that type. 953 954 So until we know for sure, we will guess at this point. 955 The heuristic is: 956 If the first member has index==indexNil or a void type, 957 assume we have an enumeration. 958 Otherwise, if there is more than one member, and all 959 the members have offset 0, assume we have a union. 960 Otherwise, assume we have a struct. 961 962 The heuristic could guess wrong in the case of of an 963 enumeration with no members or a union with one (or zero) 964 members, or when all except the last field of a struct have 965 width zero. These are uncommon and/or illegal situations, 966 and in any case guessing wrong probably doesn't matter 967 much. 968 969 But if we later do find out we were wrong, we fixup the tag 970 kind. Members of an enumeration must be handled 971 differently from struct/union fields, and that is harder to 972 patch up, but luckily we shouldn't need to. (If there are 973 any enumeration members, we can tell for sure it's an enum 974 here.) */ 975 976 if (type_code == TYPE_CODE_UNDEF) 977 { 978 if (nfields > 1 && max_value == 0) 979 type_code = TYPE_CODE_UNION; 980 else 981 type_code = TYPE_CODE_STRUCT; 982 } 983 984 /* Create a new type or use the pending type. */ 985 pend = is_pending_symbol (cur_fdr, ext_sh); 986 if (pend == (struct mdebug_pending *) NULL) 987 { 988 t = new_type (NULL); 989 add_pending (cur_fdr, ext_sh, t); 990 } 991 else 992 t = pend->t; 993 994 /* Do not set the tag name if it is a compiler generated tag name 995 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. 996 Alpha cc puts out an sh->iss of zero for those. */ 997 if (sh->iss == 0 || name[0] == '.' || name[0] == '\0') 998 TYPE_TAG_NAME (t) = NULL; 999 else 1000 TYPE_TAG_NAME (t) = obconcat (¤t_objfile->objfile_obstack, 1001 "", "", name); 1002 1003 TYPE_CODE (t) = type_code; 1004 TYPE_LENGTH (t) = sh->value; 1005 TYPE_NFIELDS (t) = nfields; 1006 TYPE_FIELDS (t) = f = ((struct field *) 1007 TYPE_ALLOC (t, 1008 nfields * sizeof (struct field))); 1009 1010 if (type_code == TYPE_CODE_ENUM) 1011 { 1012 int unsigned_enum = 1; 1013 1014 /* This is a non-empty enum. */ 1015 1016 /* DEC c89 has the number of enumerators in the sh.value field, 1017 not the type length, so we have to compensate for that 1018 incompatibility quirk. 1019 This might do the wrong thing for an enum with one or two 1020 enumerators and gcc -gcoff -fshort-enums, but these cases 1021 are hopefully rare enough. 1022 Alpha cc -migrate has a sh.value field of zero, we adjust 1023 that too. */ 1024 if (TYPE_LENGTH (t) == TYPE_NFIELDS (t) 1025 || TYPE_LENGTH (t) == 0) 1026 TYPE_LENGTH (t) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT; 1027 for (ext_tsym = ext_sh + external_sym_size; 1028 ; 1029 ext_tsym += external_sym_size) 1030 { 1031 SYMR tsym; 1032 struct symbol *enum_sym; 1033 1034 (*swap_sym_in) (cur_bfd, ext_tsym, &tsym); 1035 1036 if (tsym.st != stMember) 1037 break; 1038 1039 SET_FIELD_BITPOS (*f, tsym.value); 1040 FIELD_TYPE (*f) = t; 1041 FIELD_NAME (*f) = debug_info->ss + cur_fdr->issBase + tsym.iss; 1042 FIELD_BITSIZE (*f) = 0; 1043 1044 enum_sym = ((struct symbol *) 1045 obstack_alloc (¤t_objfile->objfile_obstack, 1046 sizeof (struct symbol))); 1047 memset (enum_sym, 0, sizeof (struct symbol)); 1048 SYMBOL_SET_LINKAGE_NAME 1049 (enum_sym, obsavestring (f->name, strlen (f->name), 1050 ¤t_objfile->objfile_obstack)); 1051 SYMBOL_CLASS (enum_sym) = LOC_CONST; 1052 SYMBOL_TYPE (enum_sym) = t; 1053 SYMBOL_DOMAIN (enum_sym) = VAR_DOMAIN; 1054 SYMBOL_VALUE (enum_sym) = tsym.value; 1055 if (SYMBOL_VALUE (enum_sym) < 0) 1056 unsigned_enum = 0; 1057 add_symbol (enum_sym, top_stack->cur_st, top_stack->cur_block); 1058 1059 /* Skip the stMembers that we've handled. */ 1060 count++; 1061 f++; 1062 } 1063 if (unsigned_enum) 1064 TYPE_UNSIGNED (t) = 1; 1065 } 1066 /* make this the current type */ 1067 top_stack->cur_type = t; 1068 top_stack->cur_field = 0; 1069 1070 /* Do not create a symbol for alpha cc unnamed structs. */ 1071 if (sh->iss == 0) 1072 break; 1073 1074 /* gcc puts out an empty struct for an opaque struct definitions, 1075 do not create a symbol for it either. */ 1076 if (TYPE_NFIELDS (t) == 0) 1077 { 1078 TYPE_STUB (t) = 1; 1079 break; 1080 } 1081 1082 s = new_symbol (name); 1083 SYMBOL_DOMAIN (s) = STRUCT_DOMAIN; 1084 SYMBOL_CLASS (s) = LOC_TYPEDEF; 1085 SYMBOL_VALUE (s) = 0; 1086 SYMBOL_TYPE (s) = t; 1087 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1088 break; 1089 1090 /* End of local variables shared by struct, union, enum, and 1091 block (as yet unknown struct/union/enum) processing. */ 1092 } 1093 1094 case_stBlock_code: 1095 found_ecoff_debugging_info = 1; 1096 /* beginnning of (code) block. Value of symbol 1097 is the displacement from procedure start */ 1098 push_parse_stack (); 1099 1100 /* Do not start a new block if this is the outermost block of a 1101 procedure. This allows the LOC_BLOCK symbol to point to the 1102 block with the local variables, so funcname::var works. */ 1103 if (top_stack->blocktype == stProc 1104 || top_stack->blocktype == stStaticProc) 1105 { 1106 top_stack->blocktype = stNil; 1107 break; 1108 } 1109 1110 top_stack->blocktype = stBlock; 1111 b = new_block (NON_FUNCTION_BLOCK); 1112 BLOCK_START (b) = sh->value + top_stack->procadr; 1113 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 1114 top_stack->cur_block = b; 1115 add_block (b, top_stack->cur_st); 1116 break; 1117 1118 case stEnd: /* end (of anything) */ 1119 if (sh->sc == scInfo || SC_IS_COMMON (sh->sc)) 1120 { 1121 /* Finished with type */ 1122 top_stack->cur_type = 0; 1123 } 1124 else if (sh->sc == scText && 1125 (top_stack->blocktype == stProc || 1126 top_stack->blocktype == stStaticProc)) 1127 { 1128 /* Finished with procedure */ 1129 struct blockvector *bv = BLOCKVECTOR (top_stack->cur_st); 1130 struct mdebug_extra_func_info *e; 1131 struct block *b = top_stack->cur_block; 1132 struct type *ftype = top_stack->cur_type; 1133 int i; 1134 1135 BLOCK_END (top_stack->cur_block) += sh->value; /* size */ 1136 1137 /* Make up special symbol to contain procedure specific info */ 1138 s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); 1139 SYMBOL_DOMAIN (s) = LABEL_DOMAIN; 1140 SYMBOL_CLASS (s) = LOC_CONST; 1141 SYMBOL_TYPE (s) = objfile_type (current_objfile)->builtin_void; 1142 e = ((struct mdebug_extra_func_info *) 1143 obstack_alloc (¤t_objfile->objfile_obstack, 1144 sizeof (struct mdebug_extra_func_info))); 1145 memset (e, 0, sizeof (struct mdebug_extra_func_info)); 1146 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; 1147 e->numargs = top_stack->numargs; 1148 e->pdr.framereg = -1; 1149 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1150 1151 /* f77 emits proc-level with address bounds==[0,0], 1152 So look for such child blocks, and patch them. */ 1153 for (i = 0; i < BLOCKVECTOR_NBLOCKS (bv); i++) 1154 { 1155 struct block *b_bad = BLOCKVECTOR_BLOCK (bv, i); 1156 if (BLOCK_SUPERBLOCK (b_bad) == b 1157 && BLOCK_START (b_bad) == top_stack->procadr 1158 && BLOCK_END (b_bad) == top_stack->procadr) 1159 { 1160 BLOCK_START (b_bad) = BLOCK_START (b); 1161 BLOCK_END (b_bad) = BLOCK_END (b); 1162 } 1163 } 1164 1165 if (TYPE_NFIELDS (ftype) <= 0) 1166 { 1167 /* No parameter type information is recorded with the function's 1168 type. Set that from the type of the parameter symbols. */ 1169 int nparams = top_stack->numargs; 1170 int iparams; 1171 struct symbol *sym; 1172 1173 if (nparams > 0) 1174 { 1175 struct dict_iterator iter; 1176 TYPE_NFIELDS (ftype) = nparams; 1177 TYPE_FIELDS (ftype) = (struct field *) 1178 TYPE_ALLOC (ftype, nparams * sizeof (struct field)); 1179 1180 iparams = 0; 1181 ALL_BLOCK_SYMBOLS (b, iter, sym) 1182 { 1183 if (iparams == nparams) 1184 break; 1185 1186 if (SYMBOL_IS_ARGUMENT (sym)) 1187 { 1188 TYPE_FIELD_TYPE (ftype, iparams) = SYMBOL_TYPE (sym); 1189 TYPE_FIELD_ARTIFICIAL (ftype, iparams) = 0; 1190 iparams++; 1191 } 1192 } 1193 } 1194 } 1195 } 1196 else if (sh->sc == scText && top_stack->blocktype == stBlock) 1197 { 1198 /* End of (code) block. The value of the symbol is the 1199 displacement from the procedure`s start address of the 1200 end of this block. */ 1201 BLOCK_END (top_stack->cur_block) = sh->value + top_stack->procadr; 1202 } 1203 else if (sh->sc == scText && top_stack->blocktype == stNil) 1204 { 1205 /* End of outermost block. Pop parse stack and ignore. The 1206 following stEnd of stProc will take care of the block. */ 1207 ; 1208 } 1209 else if (sh->sc == scText && top_stack->blocktype == stFile) 1210 { 1211 /* End of file. Pop parse stack and ignore. Higher 1212 level code deals with this. */ 1213 ; 1214 } 1215 else 1216 complaint (&symfile_complaints, 1217 _("stEnd with storage class %d not handled"), sh->sc); 1218 1219 pop_parse_stack (); /* restore previous lexical context */ 1220 break; 1221 1222 case stMember: /* member of struct or union */ 1223 f = &TYPE_FIELDS (top_stack->cur_type)[top_stack->cur_field++]; 1224 FIELD_NAME (*f) = name; 1225 SET_FIELD_BITPOS (*f, sh->value); 1226 bitsize = 0; 1227 FIELD_TYPE (*f) = parse_type (cur_fd, ax, sh->index, &bitsize, bigend, name); 1228 FIELD_BITSIZE (*f) = bitsize; 1229 break; 1230 1231 case stIndirect: /* forward declaration on Irix5 */ 1232 /* Forward declarations from Irix5 cc are handled by cross_ref, 1233 skip them. */ 1234 break; 1235 1236 case stTypedef: /* type definition */ 1237 found_ecoff_debugging_info = 1; 1238 1239 /* Typedefs for forward declarations and opaque structs from alpha cc 1240 are handled by cross_ref, skip them. */ 1241 if (sh->iss == 0) 1242 break; 1243 1244 /* Parse the type or use the pending type. */ 1245 pend = is_pending_symbol (cur_fdr, ext_sh); 1246 if (pend == (struct mdebug_pending *) NULL) 1247 { 1248 t = parse_type (cur_fd, ax, sh->index, (int *) NULL, bigend, name); 1249 add_pending (cur_fdr, ext_sh, t); 1250 } 1251 else 1252 t = pend->t; 1253 1254 /* mips cc puts out a typedef with the name of the struct for forward 1255 declarations. These should not go into the symbol table and 1256 TYPE_NAME should not be set for them. 1257 They can't be distinguished from an intentional typedef to 1258 the same name however: 1259 x.h: 1260 struct x { int ix; int jx; }; 1261 struct xx; 1262 x.c: 1263 typedef struct x x; 1264 struct xx {int ixx; int jxx; }; 1265 generates a cross referencing stTypedef for x and xx. 1266 The user visible effect of this is that the type of a pointer 1267 to struct foo sometimes is given as `foo *' instead of `struct foo *'. 1268 The problem is fixed with alpha cc and Irix5 cc. */ 1269 1270 /* However if the typedef cross references to an opaque aggregate, it 1271 is safe to omit it from the symbol table. */ 1272 1273 if (has_opaque_xref (cur_fdr, sh)) 1274 break; 1275 s = new_symbol (name); 1276 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 1277 SYMBOL_CLASS (s) = LOC_TYPEDEF; 1278 SYMBOL_BLOCK_VALUE (s) = top_stack->cur_block; 1279 SYMBOL_TYPE (s) = t; 1280 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 1281 1282 /* Incomplete definitions of structs should not get a name. */ 1283 if (TYPE_NAME (SYMBOL_TYPE (s)) == NULL 1284 && (TYPE_NFIELDS (SYMBOL_TYPE (s)) != 0 1285 || (TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_STRUCT 1286 && TYPE_CODE (SYMBOL_TYPE (s)) != TYPE_CODE_UNION))) 1287 { 1288 if (TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_PTR 1289 || TYPE_CODE (SYMBOL_TYPE (s)) == TYPE_CODE_FUNC) 1290 { 1291 /* If we are giving a name to a type such as "pointer to 1292 foo" or "function returning foo", we better not set 1293 the TYPE_NAME. If the program contains "typedef char 1294 *caddr_t;", we don't want all variables of type char 1295 * to print as caddr_t. This is not just a 1296 consequence of GDB's type management; CC and GCC (at 1297 least through version 2.4) both output variables of 1298 either type char * or caddr_t with the type 1299 refering to the stTypedef symbol for caddr_t. If a future 1300 compiler cleans this up it GDB is not ready for it 1301 yet, but if it becomes ready we somehow need to 1302 disable this check (without breaking the PCC/GCC2.4 1303 case). 1304 1305 Sigh. 1306 1307 Fortunately, this check seems not to be necessary 1308 for anything except pointers or functions. */ 1309 } 1310 else 1311 TYPE_NAME (SYMBOL_TYPE (s)) = SYMBOL_LINKAGE_NAME (s); 1312 } 1313 break; 1314 1315 case stFile: /* file name */ 1316 push_parse_stack (); 1317 top_stack->blocktype = sh->st; 1318 break; 1319 1320 /* I`ve never seen these for C */ 1321 case stRegReloc: 1322 break; /* register relocation */ 1323 case stForward: 1324 break; /* forwarding address */ 1325 case stConstant: 1326 break; /* constant */ 1327 default: 1328 complaint (&symfile_complaints, _("unknown symbol type 0x%x"), sh->st); 1329 break; 1330 } 1331 1332 return count; 1333 } 1334 1335 /* Basic types. */ 1336 1337 static const struct objfile_data *basic_type_data; 1338 1339 static struct type * 1340 basic_type (int bt, struct objfile *objfile) 1341 { 1342 struct gdbarch *gdbarch = get_objfile_arch (objfile); 1343 struct type **map_bt = objfile_data (objfile, basic_type_data); 1344 struct type *tp; 1345 1346 if (bt >= btMax) 1347 return NULL; 1348 1349 if (!map_bt) 1350 { 1351 map_bt = OBSTACK_CALLOC (&objfile->objfile_obstack, 1352 btMax, struct type *); 1353 set_objfile_data (objfile, basic_type_data, map_bt); 1354 } 1355 1356 if (map_bt[bt]) 1357 return map_bt[bt]; 1358 1359 switch (bt) 1360 { 1361 case btNil: 1362 tp = objfile_type (objfile)->builtin_void; 1363 break; 1364 1365 case btAdr: 1366 tp = init_type (TYPE_CODE_PTR, 4, TYPE_FLAG_UNSIGNED, 1367 "adr_32", objfile); 1368 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; 1369 break; 1370 1371 case btChar: 1372 tp = init_type (TYPE_CODE_INT, 1, 0, 1373 "char", objfile); 1374 break; 1375 1376 case btUChar: 1377 tp = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, 1378 "unsigned char", objfile); 1379 break; 1380 1381 case btShort: 1382 tp = init_type (TYPE_CODE_INT, 2, 0, 1383 "short", objfile); 1384 break; 1385 1386 case btUShort: 1387 tp = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, 1388 "unsigned short", objfile); 1389 break; 1390 1391 case btInt: 1392 tp = init_type (TYPE_CODE_INT, 4, 0, 1393 "int", objfile); 1394 break; 1395 1396 case btUInt: 1397 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 1398 "unsigned int", objfile); 1399 break; 1400 1401 case btLong: 1402 tp = init_type (TYPE_CODE_INT, 4, 0, 1403 "long", objfile); 1404 break; 1405 1406 case btULong: 1407 tp = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 1408 "unsigned long", objfile); 1409 break; 1410 1411 case btFloat: 1412 tp = init_type (TYPE_CODE_FLT, 1413 gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1414 "float", objfile); 1415 break; 1416 1417 case btDouble: 1418 tp = init_type (TYPE_CODE_FLT, 1419 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1420 "double", objfile); 1421 break; 1422 1423 case btComplex: 1424 tp = init_type (TYPE_CODE_COMPLEX, 1425 2 * gdbarch_float_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1426 "complex", objfile); 1427 TYPE_TARGET_TYPE (tp) = basic_type (btFloat, objfile); 1428 break; 1429 1430 case btDComplex: 1431 tp = init_type (TYPE_CODE_COMPLEX, 1432 2 * gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1433 "double complex", objfile); 1434 TYPE_TARGET_TYPE (tp) = basic_type (btDouble, objfile); 1435 break; 1436 1437 case btFixedDec: 1438 /* We use TYPE_CODE_INT to print these as integers. Does this do any 1439 good? Would we be better off with TYPE_CODE_ERROR? Should 1440 TYPE_CODE_ERROR print things in hex if it knows the size? */ 1441 tp = init_type (TYPE_CODE_INT, 1442 gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1443 "fixed decimal", objfile); 1444 break; 1445 1446 case btFloatDec: 1447 tp = init_type (TYPE_CODE_ERROR, 1448 gdbarch_double_bit (gdbarch) / TARGET_CHAR_BIT, 0, 1449 "floating decimal", objfile); 1450 break; 1451 1452 case btString: 1453 /* Is a "string" the way btString means it the same as TYPE_CODE_STRING? 1454 FIXME. */ 1455 tp = init_type (TYPE_CODE_STRING, 1, 0, 1456 "string", objfile); 1457 break; 1458 1459 case btVoid: 1460 tp = objfile_type (objfile)->builtin_void; 1461 break; 1462 1463 case btLong64: 1464 tp = init_type (TYPE_CODE_INT, 8, 0, 1465 "long", objfile); 1466 break; 1467 1468 case btULong64: 1469 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1470 "unsigned long", objfile); 1471 break; 1472 1473 case btLongLong64: 1474 tp = init_type (TYPE_CODE_INT, 8, 0, 1475 "long long", objfile); 1476 break; 1477 1478 case btULongLong64: 1479 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1480 "unsigned long long", objfile); 1481 break; 1482 1483 case btAdr64: 1484 tp = init_type (TYPE_CODE_PTR, 8, TYPE_FLAG_UNSIGNED, 1485 "adr_64", objfile); 1486 TYPE_TARGET_TYPE (tp) = objfile_type (objfile)->builtin_void; 1487 break; 1488 1489 case btInt64: 1490 tp = init_type (TYPE_CODE_INT, 8, 0, 1491 "int", objfile); 1492 break; 1493 1494 case btUInt64: 1495 tp = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 1496 "unsigned int", objfile); 1497 break; 1498 1499 default: 1500 tp = NULL; 1501 break; 1502 } 1503 1504 map_bt[bt] = tp; 1505 return tp; 1506 } 1507 1508 /* Parse the type information provided in the raw AX entries for 1509 the symbol SH. Return the bitfield size in BS, in case. 1510 We must byte-swap the AX entries before we use them; BIGEND says whether 1511 they are big-endian or little-endian (from fh->fBigendian). */ 1512 1513 static struct type * 1514 parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs, 1515 int bigend, char *sym_name) 1516 { 1517 TIR t[1]; 1518 struct type *tp = 0; 1519 enum type_code type_code = TYPE_CODE_UNDEF; 1520 1521 /* Handle undefined types, they have indexNil. */ 1522 if (aux_index == indexNil) 1523 return basic_type (btInt, current_objfile); 1524 1525 /* Handle corrupt aux indices. */ 1526 if (aux_index >= (debug_info->fdr + fd)->caux) 1527 { 1528 index_complaint (sym_name); 1529 return basic_type (btInt, current_objfile); 1530 } 1531 ax += aux_index; 1532 1533 /* Use aux as a type information record, map its basic type. */ 1534 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); 1535 tp = basic_type (t->bt, current_objfile); 1536 if (tp == NULL) 1537 { 1538 /* Cannot use builtin types -- build our own */ 1539 switch (t->bt) 1540 { 1541 case btStruct: 1542 type_code = TYPE_CODE_STRUCT; 1543 break; 1544 case btUnion: 1545 type_code = TYPE_CODE_UNION; 1546 break; 1547 case btEnum: 1548 type_code = TYPE_CODE_ENUM; 1549 break; 1550 case btRange: 1551 type_code = TYPE_CODE_RANGE; 1552 break; 1553 case btSet: 1554 type_code = TYPE_CODE_SET; 1555 break; 1556 case btIndirect: 1557 /* alpha cc -migrate uses this for typedefs. The true type will 1558 be obtained by crossreferencing below. */ 1559 type_code = TYPE_CODE_ERROR; 1560 break; 1561 case btTypedef: 1562 /* alpha cc uses this for typedefs. The true type will be 1563 obtained by crossreferencing below. */ 1564 type_code = TYPE_CODE_ERROR; 1565 break; 1566 default: 1567 basic_type_complaint (t->bt, sym_name); 1568 return basic_type (btInt, current_objfile); 1569 } 1570 } 1571 1572 /* Move on to next aux */ 1573 ax++; 1574 1575 if (t->fBitfield) 1576 { 1577 int width = AUX_GET_WIDTH (bigend, ax); 1578 /* Inhibit core dumps if TIR is corrupted. */ 1579 if (bs == (int *) NULL) 1580 { 1581 /* Alpha cc -migrate encodes char and unsigned char types 1582 as short and unsigned short types with a field width of 8. 1583 Enum types also have a field width which we ignore for now. */ 1584 if (t->bt == btShort && width == 8) 1585 tp = basic_type (btChar, current_objfile); 1586 else if (t->bt == btUShort && width == 8) 1587 tp = basic_type (btUChar, current_objfile); 1588 else if (t->bt == btEnum) 1589 ; 1590 else 1591 complaint (&symfile_complaints, _("can't handle TIR fBitfield for %s"), 1592 sym_name); 1593 } 1594 else 1595 *bs = width; 1596 ax++; 1597 } 1598 1599 /* A btIndirect entry cross references to an aux entry containing 1600 the type. */ 1601 if (t->bt == btIndirect) 1602 { 1603 RNDXR rn[1]; 1604 int rf; 1605 FDR *xref_fh; 1606 int xref_fd; 1607 1608 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn); 1609 ax++; 1610 if (rn->rfd == 0xfff) 1611 { 1612 rf = AUX_GET_ISYM (bigend, ax); 1613 ax++; 1614 } 1615 else 1616 rf = rn->rfd; 1617 1618 if (rf == -1) 1619 { 1620 complaint (&symfile_complaints, 1621 _("unable to cross ref btIndirect for %s"), sym_name); 1622 return basic_type (btInt, current_objfile); 1623 } 1624 xref_fh = get_rfd (fd, rf); 1625 xref_fd = xref_fh - debug_info->fdr; 1626 tp = parse_type (xref_fd, debug_info->external_aux + xref_fh->iauxBase, 1627 rn->index, (int *) NULL, xref_fh->fBigendian, sym_name); 1628 } 1629 1630 /* All these types really point to some (common) MIPS type 1631 definition, and only the type-qualifiers fully identify 1632 them. We'll make the same effort at sharing. */ 1633 if (t->bt == btStruct || 1634 t->bt == btUnion || 1635 t->bt == btEnum || 1636 1637 /* btSet (I think) implies that the name is a tag name, not a typedef 1638 name. This apparently is a MIPS extension for C sets. */ 1639 t->bt == btSet) 1640 { 1641 char *name; 1642 1643 /* Try to cross reference this type, build new type on failure. */ 1644 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1645 if (tp == (struct type *) NULL) 1646 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); 1647 1648 /* DEC c89 produces cross references to qualified aggregate types, 1649 dereference them. */ 1650 while (TYPE_CODE (tp) == TYPE_CODE_PTR 1651 || TYPE_CODE (tp) == TYPE_CODE_ARRAY) 1652 tp = TYPE_TARGET_TYPE (tp); 1653 1654 /* Make sure that TYPE_CODE(tp) has an expected type code. 1655 Any type may be returned from cross_ref if file indirect entries 1656 are corrupted. */ 1657 if (TYPE_CODE (tp) != TYPE_CODE_STRUCT 1658 && TYPE_CODE (tp) != TYPE_CODE_UNION 1659 && TYPE_CODE (tp) != TYPE_CODE_ENUM) 1660 { 1661 unexpected_type_code_complaint (sym_name); 1662 } 1663 else 1664 { 1665 1666 /* Usually, TYPE_CODE(tp) is already type_code. The main 1667 exception is if we guessed wrong re struct/union/enum. 1668 But for struct vs. union a wrong guess is harmless, so 1669 don't complain(). */ 1670 if ((TYPE_CODE (tp) == TYPE_CODE_ENUM 1671 && type_code != TYPE_CODE_ENUM) 1672 || (TYPE_CODE (tp) != TYPE_CODE_ENUM 1673 && type_code == TYPE_CODE_ENUM)) 1674 { 1675 bad_tag_guess_complaint (sym_name); 1676 } 1677 1678 if (TYPE_CODE (tp) != type_code) 1679 { 1680 TYPE_CODE (tp) = type_code; 1681 } 1682 1683 /* Do not set the tag name if it is a compiler generated tag name 1684 (.Fxx or .xxfake or empty) for unnamed struct/union/enums. */ 1685 if (name[0] == '.' || name[0] == '\0') 1686 TYPE_TAG_NAME (tp) = NULL; 1687 else if (TYPE_TAG_NAME (tp) == NULL 1688 || strcmp (TYPE_TAG_NAME (tp), name) != 0) 1689 TYPE_TAG_NAME (tp) = obsavestring (name, strlen (name), 1690 ¤t_objfile->objfile_obstack); 1691 } 1692 } 1693 1694 /* All these types really point to some (common) MIPS type 1695 definition, and only the type-qualifiers fully identify 1696 them. We'll make the same effort at sharing. 1697 FIXME: We are not doing any guessing on range types. */ 1698 if (t->bt == btRange) 1699 { 1700 char *name; 1701 1702 /* Try to cross reference this type, build new type on failure. */ 1703 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1704 if (tp == (struct type *) NULL) 1705 tp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); 1706 1707 /* Make sure that TYPE_CODE(tp) has an expected type code. 1708 Any type may be returned from cross_ref if file indirect entries 1709 are corrupted. */ 1710 if (TYPE_CODE (tp) != TYPE_CODE_RANGE) 1711 { 1712 unexpected_type_code_complaint (sym_name); 1713 } 1714 else 1715 { 1716 /* Usually, TYPE_CODE(tp) is already type_code. The main 1717 exception is if we guessed wrong re struct/union/enum. */ 1718 if (TYPE_CODE (tp) != type_code) 1719 { 1720 bad_tag_guess_complaint (sym_name); 1721 TYPE_CODE (tp) = type_code; 1722 } 1723 if (TYPE_NAME (tp) == NULL 1724 || strcmp (TYPE_NAME (tp), name) != 0) 1725 TYPE_NAME (tp) = obsavestring (name, strlen (name), 1726 ¤t_objfile->objfile_obstack); 1727 } 1728 } 1729 if (t->bt == btTypedef) 1730 { 1731 char *name; 1732 1733 /* Try to cross reference this type, it should succeed. */ 1734 ax += cross_ref (fd, ax, &tp, type_code, &name, bigend, sym_name); 1735 if (tp == (struct type *) NULL) 1736 { 1737 complaint (&symfile_complaints, 1738 _("unable to cross ref btTypedef for %s"), sym_name); 1739 tp = basic_type (btInt, current_objfile); 1740 } 1741 } 1742 1743 /* Deal with range types */ 1744 if (t->bt == btRange) 1745 { 1746 TYPE_NFIELDS (tp) = 2; 1747 TYPE_FIELDS (tp) = ((struct field *) 1748 TYPE_ALLOC (tp, 2 * sizeof (struct field))); 1749 TYPE_FIELD_NAME (tp, 0) = obsavestring ("Low", strlen ("Low"), 1750 ¤t_objfile->objfile_obstack); 1751 TYPE_LOW_BOUND (tp) = AUX_GET_DNLOW (bigend, ax); 1752 ax++; 1753 TYPE_FIELD_NAME (tp, 1) = obsavestring ("High", strlen ("High"), 1754 ¤t_objfile->objfile_obstack); 1755 TYPE_HIGH_BOUND (tp) = AUX_GET_DNHIGH (bigend, ax); 1756 ax++; 1757 } 1758 1759 /* Parse all the type qualifiers now. If there are more 1760 than 6 the game will continue in the next aux */ 1761 1762 while (1) 1763 { 1764 #define PARSE_TQ(tq) \ 1765 if (t->tq != tqNil) \ 1766 ax += upgrade_type(fd, &tp, t->tq, ax, bigend, sym_name); \ 1767 else \ 1768 break; 1769 1770 PARSE_TQ (tq0); 1771 PARSE_TQ (tq1); 1772 PARSE_TQ (tq2); 1773 PARSE_TQ (tq3); 1774 PARSE_TQ (tq4); 1775 PARSE_TQ (tq5); 1776 #undef PARSE_TQ 1777 1778 /* mips cc 2.x and gcc never put out continued aux entries. */ 1779 if (!t->continued) 1780 break; 1781 1782 (*debug_swap->swap_tir_in) (bigend, &ax->a_ti, t); 1783 ax++; 1784 } 1785 1786 /* Complain for illegal continuations due to corrupt aux entries. */ 1787 if (t->continued) 1788 complaint (&symfile_complaints, _("illegal TIR continued for %s"), sym_name); 1789 1790 return tp; 1791 } 1792 1793 /* Make up a complex type from a basic one. Type is passed by 1794 reference in TPP and side-effected as necessary. The type 1795 qualifier TQ says how to handle the aux symbols at AX for 1796 the symbol SX we are currently analyzing. BIGEND says whether 1797 aux symbols are big-endian or little-endian. 1798 Returns the number of aux symbols we parsed. */ 1799 1800 static int 1801 upgrade_type (int fd, struct type **tpp, int tq, union aux_ext *ax, int bigend, 1802 char *sym_name) 1803 { 1804 int off; 1805 struct type *t; 1806 1807 /* Used in array processing */ 1808 int rf, id; 1809 FDR *fh; 1810 struct type *range; 1811 struct type *indx; 1812 int lower, upper; 1813 RNDXR rndx; 1814 1815 switch (tq) 1816 { 1817 case tqPtr: 1818 t = lookup_pointer_type (*tpp); 1819 *tpp = t; 1820 return 0; 1821 1822 case tqProc: 1823 t = lookup_function_type (*tpp); 1824 *tpp = t; 1825 return 0; 1826 1827 case tqArray: 1828 off = 0; 1829 1830 /* Determine and record the domain type (type of index) */ 1831 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, &rndx); 1832 id = rndx.index; 1833 rf = rndx.rfd; 1834 if (rf == 0xfff) 1835 { 1836 ax++; 1837 rf = AUX_GET_ISYM (bigend, ax); 1838 off++; 1839 } 1840 fh = get_rfd (fd, rf); 1841 1842 indx = parse_type (fh - debug_info->fdr, 1843 debug_info->external_aux + fh->iauxBase, 1844 id, (int *) NULL, bigend, sym_name); 1845 1846 /* The bounds type should be an integer type, but might be anything 1847 else due to corrupt aux entries. */ 1848 if (TYPE_CODE (indx) != TYPE_CODE_INT) 1849 { 1850 complaint (&symfile_complaints, 1851 _("illegal array index type for %s, assuming int"), sym_name); 1852 indx = objfile_type (current_objfile)->builtin_int; 1853 } 1854 1855 /* Get the bounds, and create the array type. */ 1856 ax++; 1857 lower = AUX_GET_DNLOW (bigend, ax); 1858 ax++; 1859 upper = AUX_GET_DNHIGH (bigend, ax); 1860 ax++; 1861 rf = AUX_GET_WIDTH (bigend, ax); /* bit size of array element */ 1862 1863 range = create_range_type ((struct type *) NULL, indx, 1864 lower, upper); 1865 1866 t = create_array_type ((struct type *) NULL, *tpp, range); 1867 1868 /* We used to fill in the supplied array element bitsize 1869 here if the TYPE_LENGTH of the target type was zero. 1870 This happens for a `pointer to an array of anonymous structs', 1871 but in this case the array element bitsize is also zero, 1872 so nothing is gained. 1873 And we used to check the TYPE_LENGTH of the target type against 1874 the supplied array element bitsize. 1875 gcc causes a mismatch for `pointer to array of object', 1876 since the sdb directives it uses do not have a way of 1877 specifying the bitsize, but it does no harm (the 1878 TYPE_LENGTH should be correct) and we should be able to 1879 ignore the erroneous bitsize from the auxiliary entry safely. 1880 dbx seems to ignore it too. */ 1881 1882 /* TYPE_TARGET_STUB now takes care of the zero TYPE_LENGTH problem. */ 1883 if (TYPE_LENGTH (*tpp) == 0) 1884 TYPE_TARGET_STUB (t) = 1; 1885 1886 *tpp = t; 1887 return 4 + off; 1888 1889 case tqVol: 1890 /* Volatile -- currently ignored */ 1891 return 0; 1892 1893 case tqConst: 1894 /* Const -- currently ignored */ 1895 return 0; 1896 1897 default: 1898 complaint (&symfile_complaints, _("unknown type qualifier 0x%x"), tq); 1899 return 0; 1900 } 1901 } 1902 1903 1904 /* Parse a procedure descriptor record PR. Note that the procedure is 1905 parsed _after_ the local symbols, now we just insert the extra 1906 information we need into a MDEBUG_EFI_SYMBOL_NAME symbol that has 1907 already been placed in the procedure's main block. Note also that 1908 images that have been partially stripped (ld -x) have been deprived 1909 of local symbols, and we have to cope with them here. FIRST_OFF is 1910 the offset of the first procedure for this FDR; we adjust the 1911 address by this amount, but I don't know why. SEARCH_SYMTAB is the symtab 1912 to look for the function which contains the MDEBUG_EFI_SYMBOL_NAME symbol 1913 in question, or NULL to use top_stack->cur_block. */ 1914 1915 static void parse_procedure (PDR *, struct symtab *, struct partial_symtab *); 1916 1917 static void 1918 parse_procedure (PDR *pr, struct symtab *search_symtab, 1919 struct partial_symtab *pst) 1920 { 1921 struct symbol *s, *i; 1922 struct block *b; 1923 char *sh_name; 1924 1925 /* Simple rule to find files linked "-x" */ 1926 if (cur_fdr->rss == -1) 1927 { 1928 if (pr->isym == -1) 1929 { 1930 /* Static procedure at address pr->adr. Sigh. */ 1931 /* FIXME-32x64. assuming pr->adr fits in long. */ 1932 complaint (&symfile_complaints, 1933 _("can't handle PDR for static proc at 0x%lx"), 1934 (unsigned long) pr->adr); 1935 return; 1936 } 1937 else 1938 { 1939 /* external */ 1940 EXTR she; 1941 1942 (*debug_swap->swap_ext_in) (cur_bfd, 1943 ((char *) debug_info->external_ext 1944 + (pr->isym 1945 * debug_swap->external_ext_size)), 1946 &she); 1947 sh_name = debug_info->ssext + she.asym.iss; 1948 } 1949 } 1950 else 1951 { 1952 /* Full symbols */ 1953 SYMR sh; 1954 1955 (*debug_swap->swap_sym_in) (cur_bfd, 1956 ((char *) debug_info->external_sym 1957 + ((cur_fdr->isymBase + pr->isym) 1958 * debug_swap->external_sym_size)), 1959 &sh); 1960 sh_name = debug_info->ss + cur_fdr->issBase + sh.iss; 1961 } 1962 1963 if (search_symtab != NULL) 1964 { 1965 #if 0 1966 /* This loses both in the case mentioned (want a static, find a global), 1967 but also if we are looking up a non-mangled name which happens to 1968 match the name of a mangled function. */ 1969 /* We have to save the cur_fdr across the call to lookup_symbol. 1970 If the pdr is for a static function and if a global function with 1971 the same name exists, lookup_symbol will eventually read in the symtab 1972 for the global function and clobber cur_fdr. */ 1973 FDR *save_cur_fdr = cur_fdr; 1974 s = lookup_symbol (sh_name, NULL, VAR_DOMAIN, 0); 1975 cur_fdr = save_cur_fdr; 1976 #else 1977 s = mylookup_symbol 1978 (sh_name, 1979 BLOCKVECTOR_BLOCK (BLOCKVECTOR (search_symtab), STATIC_BLOCK), 1980 VAR_DOMAIN, 1981 LOC_BLOCK); 1982 #endif 1983 } 1984 else 1985 s = mylookup_symbol (sh_name, top_stack->cur_block, 1986 VAR_DOMAIN, LOC_BLOCK); 1987 1988 if (s != 0) 1989 { 1990 b = SYMBOL_BLOCK_VALUE (s); 1991 } 1992 else 1993 { 1994 complaint (&symfile_complaints, _("PDR for %s, but no symbol"), sh_name); 1995 #if 1 1996 return; 1997 #else 1998 /* FIXME -- delete. We can't do symbol allocation now; it's all done. */ 1999 s = new_symbol (sh_name); 2000 SYMBOL_DOMAIN (s) = VAR_DOMAIN; 2001 SYMBOL_CLASS (s) = LOC_BLOCK; 2002 /* Donno its type, hope int is ok */ 2003 SYMBOL_TYPE (s) 2004 = lookup_function_type (objfile_type (pst->objfile)->builtin_int); 2005 add_symbol (s, top_stack->cur_st, top_stack->cur_block); 2006 /* Wont have symbols for this one */ 2007 b = new_block (2); 2008 SYMBOL_BLOCK_VALUE (s) = b; 2009 BLOCK_FUNCTION (b) = s; 2010 BLOCK_START (b) = pr->adr; 2011 /* BOUND used to be the end of procedure's text, but the 2012 argument is no longer passed in. */ 2013 BLOCK_END (b) = bound; 2014 BLOCK_SUPERBLOCK (b) = top_stack->cur_block; 2015 add_block (b, top_stack->cur_st); 2016 #endif 2017 } 2018 2019 i = mylookup_symbol (MDEBUG_EFI_SYMBOL_NAME, b, LABEL_DOMAIN, LOC_CONST); 2020 2021 if (i) 2022 { 2023 struct mdebug_extra_func_info *e; 2024 2025 e = (struct mdebug_extra_func_info *) SYMBOL_VALUE_BYTES (i); 2026 e->pdr = *pr; 2027 2028 /* GDB expects the absolute function start address for the 2029 procedure descriptor in e->pdr.adr. 2030 As the address in the procedure descriptor is usually relative, 2031 we would have to relocate e->pdr.adr with cur_fdr->adr and 2032 ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)). 2033 Unfortunately cur_fdr->adr and e->pdr.adr are both absolute 2034 in shared libraries on some systems, and on other systems 2035 e->pdr.adr is sometimes offset by a bogus value. 2036 To work around these problems, we replace e->pdr.adr with 2037 the start address of the function. */ 2038 e->pdr.adr = BLOCK_START (b); 2039 } 2040 2041 /* It would be reasonable that functions that have been compiled 2042 without debugging info have a btNil type for their return value, 2043 and functions that are void and are compiled with debugging info 2044 have btVoid. 2045 gcc and DEC f77 put out btNil types for both cases, so btNil is mapped 2046 to TYPE_CODE_VOID in parse_type to get the `compiled with debugging info' 2047 case right. 2048 The glevel field in cur_fdr could be used to determine the presence 2049 of debugging info, but GCC doesn't always pass the -g switch settings 2050 to the assembler and GAS doesn't set the glevel field from the -g switch 2051 settings. 2052 To work around these problems, the return value type of a TYPE_CODE_VOID 2053 function is adjusted accordingly if no debugging info was found in the 2054 compilation unit. */ 2055 2056 if (processing_gcc_compilation == 0 2057 && found_ecoff_debugging_info == 0 2058 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (s))) == TYPE_CODE_VOID) 2059 SYMBOL_TYPE (s) = objfile_type (pst->objfile)->nodebug_text_symbol; 2060 } 2061 2062 /* Parse the external symbol ES. Just call parse_symbol() after 2063 making sure we know where the aux are for it. 2064 BIGEND says whether aux entries are big-endian or little-endian. 2065 2066 This routine clobbers top_stack->cur_block and ->cur_st. */ 2067 2068 static void parse_external (EXTR *, int, struct section_offsets *, 2069 struct objfile *); 2070 2071 static void 2072 parse_external (EXTR *es, int bigend, struct section_offsets *section_offsets, 2073 struct objfile *objfile) 2074 { 2075 union aux_ext *ax; 2076 2077 if (es->ifd != ifdNil) 2078 { 2079 cur_fd = es->ifd; 2080 cur_fdr = debug_info->fdr + cur_fd; 2081 ax = debug_info->external_aux + cur_fdr->iauxBase; 2082 } 2083 else 2084 { 2085 cur_fdr = debug_info->fdr; 2086 ax = 0; 2087 } 2088 2089 /* Reading .o files */ 2090 if (SC_IS_UNDEF (es->asym.sc) || es->asym.sc == scNil) 2091 { 2092 char *what; 2093 switch (es->asym.st) 2094 { 2095 case stNil: 2096 /* These are generated for static symbols in .o files, 2097 ignore them. */ 2098 return; 2099 case stStaticProc: 2100 case stProc: 2101 what = "procedure"; 2102 n_undef_procs++; 2103 break; 2104 case stGlobal: 2105 what = "variable"; 2106 n_undef_vars++; 2107 break; 2108 case stLabel: 2109 what = "label"; 2110 n_undef_labels++; 2111 break; 2112 default: 2113 what = "symbol"; 2114 break; 2115 } 2116 n_undef_symbols++; 2117 /* FIXME: Turn this into a complaint? */ 2118 if (info_verbose) 2119 printf_filtered (_("Warning: %s `%s' is undefined (in %s)\n"), 2120 what, debug_info->ssext + es->asym.iss, 2121 fdr_name (cur_fdr)); 2122 return; 2123 } 2124 2125 switch (es->asym.st) 2126 { 2127 case stProc: 2128 case stStaticProc: 2129 /* There is no need to parse the external procedure symbols. 2130 If they are from objects compiled without -g, their index will 2131 be indexNil, and the symbol definition from the minimal symbol 2132 is preferrable (yielding a function returning int instead of int). 2133 If the index points to a local procedure symbol, the local 2134 symbol already provides the correct type. 2135 Note that the index of the external procedure symbol points 2136 to the local procedure symbol in the local symbol table, and 2137 _not_ to the auxiliary symbol info. */ 2138 break; 2139 case stGlobal: 2140 case stLabel: 2141 /* Global common symbols are resolved by the runtime loader, 2142 ignore them. */ 2143 if (SC_IS_COMMON (es->asym.sc)) 2144 break; 2145 2146 /* Note that the case of a symbol with indexNil must be handled 2147 anyways by parse_symbol(). */ 2148 parse_symbol (&es->asym, ax, (char *) NULL, bigend, section_offsets, objfile); 2149 break; 2150 default: 2151 break; 2152 } 2153 } 2154 2155 /* Parse the line number info for file descriptor FH into 2156 GDB's linetable LT. MIPS' encoding requires a little bit 2157 of magic to get things out. Note also that MIPS' line 2158 numbers can go back and forth, apparently we can live 2159 with that and do not need to reorder our linetables */ 2160 2161 static void parse_lines (FDR *, PDR *, struct linetable *, int, 2162 struct partial_symtab *, CORE_ADDR); 2163 2164 static void 2165 parse_lines (FDR *fh, PDR *pr, struct linetable *lt, int maxlines, 2166 struct partial_symtab *pst, CORE_ADDR lowest_pdr_addr) 2167 { 2168 unsigned char *base; 2169 int j, k; 2170 int delta, count, lineno = 0; 2171 2172 if (fh->cbLine == 0) 2173 return; 2174 2175 /* Scan by procedure descriptors */ 2176 k = 0; 2177 for (j = 0; j < fh->cpd; j++, pr++) 2178 { 2179 CORE_ADDR l; 2180 CORE_ADDR adr; 2181 unsigned char *halt; 2182 2183 /* No code for this one */ 2184 if (pr->iline == ilineNil || 2185 pr->lnLow == -1 || pr->lnHigh == -1) 2186 continue; 2187 2188 /* Determine start and end address of compressed line bytes for 2189 this procedure. */ 2190 base = debug_info->line + fh->cbLineOffset; 2191 if (j != (fh->cpd - 1)) 2192 halt = base + pr[1].cbLineOffset; 2193 else 2194 halt = base + fh->cbLine; 2195 base += pr->cbLineOffset; 2196 2197 adr = pst->textlow + pr->adr - lowest_pdr_addr; 2198 2199 l = adr >> 2; /* in words */ 2200 for (lineno = pr->lnLow; base < halt;) 2201 { 2202 count = *base & 0x0f; 2203 delta = *base++ >> 4; 2204 if (delta >= 8) 2205 delta -= 16; 2206 if (delta == -8) 2207 { 2208 delta = (base[0] << 8) | base[1]; 2209 if (delta >= 0x8000) 2210 delta -= 0x10000; 2211 base += 2; 2212 } 2213 lineno += delta; /* first delta is 0 */ 2214 2215 /* Complain if the line table overflows. Could happen 2216 with corrupt binaries. */ 2217 if (lt->nitems >= maxlines) 2218 { 2219 complaint (&symfile_complaints, 2220 _("guessed size of linetable for %s incorrectly"), 2221 fdr_name (fh)); 2222 break; 2223 } 2224 k = add_line (lt, lineno, l, k); 2225 l += count + 1; 2226 } 2227 } 2228 } 2229 2230 static void 2231 function_outside_compilation_unit_complaint (const char *arg1) 2232 { 2233 complaint (&symfile_complaints, 2234 _("function `%s' appears to be defined outside of all compilation units"), 2235 arg1); 2236 } 2237 2238 /* Use the STORAGE_CLASS to compute which section the given symbol 2239 belongs to, and then records this new minimal symbol. */ 2240 2241 static void 2242 record_minimal_symbol (const char *name, const CORE_ADDR address, 2243 enum minimal_symbol_type ms_type, int storage_class, 2244 struct objfile *objfile) 2245 { 2246 int section; 2247 asection *bfd_section; 2248 2249 switch (storage_class) 2250 { 2251 case scText: 2252 section = SECT_OFF_TEXT (objfile); 2253 bfd_section = bfd_get_section_by_name (cur_bfd, ".text"); 2254 break; 2255 case scData: 2256 section = SECT_OFF_DATA (objfile); 2257 bfd_section = bfd_get_section_by_name (cur_bfd, ".data"); 2258 break; 2259 case scBss: 2260 section = SECT_OFF_BSS (objfile); 2261 bfd_section = bfd_get_section_by_name (cur_bfd, ".bss"); 2262 break; 2263 case scSData: 2264 section = get_section_index (objfile, ".sdata"); 2265 bfd_section = bfd_get_section_by_name (cur_bfd, ".sdata"); 2266 break; 2267 case scSBss: 2268 section = get_section_index (objfile, ".sbss"); 2269 bfd_section = bfd_get_section_by_name (cur_bfd, ".sbss"); 2270 break; 2271 case scRData: 2272 section = get_section_index (objfile, ".rdata"); 2273 bfd_section = bfd_get_section_by_name (cur_bfd, ".rdata"); 2274 break; 2275 case scInit: 2276 section = get_section_index (objfile, ".init"); 2277 bfd_section = bfd_get_section_by_name (cur_bfd, ".init"); 2278 break; 2279 case scXData: 2280 section = get_section_index (objfile, ".xdata"); 2281 bfd_section = bfd_get_section_by_name (cur_bfd, ".xdata"); 2282 break; 2283 case scPData: 2284 section = get_section_index (objfile, ".pdata"); 2285 bfd_section = bfd_get_section_by_name (cur_bfd, ".pdata"); 2286 break; 2287 case scFini: 2288 section = get_section_index (objfile, ".fini"); 2289 bfd_section = bfd_get_section_by_name (cur_bfd, ".fini"); 2290 break; 2291 case scRConst: 2292 section = get_section_index (objfile, ".rconst"); 2293 bfd_section = bfd_get_section_by_name (cur_bfd, ".rconst"); 2294 break; 2295 #ifdef scTlsData 2296 case scTlsData: 2297 section = get_section_index (objfile, ".tlsdata"); 2298 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsdata"); 2299 break; 2300 #endif 2301 #ifdef scTlsBss 2302 case scTlsBss: 2303 section = get_section_index (objfile, ".tlsbss"); 2304 bfd_section = bfd_get_section_by_name (cur_bfd, ".tlsbss"); 2305 break; 2306 #endif 2307 default: 2308 /* This kind of symbol is not associated to a section. */ 2309 section = -1; 2310 bfd_section = NULL; 2311 } 2312 2313 prim_record_minimal_symbol_and_info (name, address, ms_type, 2314 section, bfd_section, objfile); 2315 } 2316 2317 /* Master parsing procedure for first-pass reading of file symbols 2318 into a partial_symtab. */ 2319 2320 static void 2321 parse_partial_symbols (struct objfile *objfile) 2322 { 2323 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2324 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 2325 const bfd_size_type external_rfd_size = debug_swap->external_rfd_size; 2326 const bfd_size_type external_ext_size = debug_swap->external_ext_size; 2327 void (*const swap_ext_in) (bfd *, void *, EXTR *) = debug_swap->swap_ext_in; 2328 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 2329 void (*const swap_rfd_in) (bfd *, void *, RFDT *) = debug_swap->swap_rfd_in; 2330 int f_idx, s_idx; 2331 HDRR *hdr = &debug_info->symbolic_header; 2332 /* Running pointers */ 2333 FDR *fh; 2334 char *ext_out; 2335 char *ext_out_end; 2336 EXTR *ext_block; 2337 EXTR *ext_in; 2338 EXTR *ext_in_end; 2339 SYMR sh; 2340 struct partial_symtab *pst; 2341 int textlow_not_set = 1; 2342 int past_first_source_file = 0; 2343 2344 /* List of current psymtab's include files */ 2345 char **psymtab_include_list; 2346 int includes_allocated; 2347 int includes_used; 2348 EXTR *extern_tab; 2349 struct pst_map *fdr_to_pst; 2350 /* Index within current psymtab dependency list */ 2351 struct partial_symtab **dependency_list; 2352 int dependencies_used, dependencies_allocated; 2353 struct cleanup *old_chain; 2354 char *name; 2355 enum language prev_language; 2356 asection *text_sect; 2357 int relocatable = 0; 2358 2359 /* Irix 5.2 shared libraries have a fh->adr field of zero, but 2360 the shared libraries are prelinked at a high memory address. 2361 We have to adjust the start address of the object file for this case, 2362 by setting it to the start address of the first procedure in the file. 2363 But we should do no adjustments if we are debugging a .o file, where 2364 the text section (and fh->adr) really starts at zero. */ 2365 text_sect = bfd_get_section_by_name (cur_bfd, ".text"); 2366 if (text_sect != NULL 2367 && (bfd_get_section_flags (cur_bfd, text_sect) & SEC_RELOC)) 2368 relocatable = 1; 2369 2370 extern_tab = (EXTR *) obstack_alloc (&objfile->objfile_obstack, 2371 sizeof (EXTR) * hdr->iextMax); 2372 2373 includes_allocated = 30; 2374 includes_used = 0; 2375 psymtab_include_list = (char **) alloca (includes_allocated * 2376 sizeof (char *)); 2377 next_symbol_text_func = mdebug_next_symbol_text; 2378 2379 dependencies_allocated = 30; 2380 dependencies_used = 0; 2381 dependency_list = 2382 (struct partial_symtab **) alloca (dependencies_allocated * 2383 sizeof (struct partial_symtab *)); 2384 2385 last_source_file = NULL; 2386 2387 /* 2388 * Big plan: 2389 * 2390 * Only parse the Local and External symbols, and the Relative FDR. 2391 * Fixup enough of the loader symtab to be able to use it. 2392 * Allocate space only for the file's portions we need to 2393 * look at. (XXX) 2394 */ 2395 2396 max_gdbinfo = 0; 2397 max_glevel = MIN_GLEVEL; 2398 2399 /* Allocate the map FDR -> PST. 2400 Minor hack: -O3 images might claim some global data belongs 2401 to FDR -1. We`ll go along with that */ 2402 fdr_to_pst = (struct pst_map *) xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst); 2403 old_chain = make_cleanup (xfree, fdr_to_pst); 2404 fdr_to_pst++; 2405 { 2406 struct partial_symtab *pst = new_psymtab ("", objfile); 2407 fdr_to_pst[-1].pst = pst; 2408 FDR_IDX (pst) = -1; 2409 } 2410 2411 /* Allocate the global pending list. */ 2412 pending_list = 2413 ((struct mdebug_pending **) 2414 obstack_alloc (&objfile->objfile_obstack, 2415 hdr->ifdMax * sizeof (struct mdebug_pending *))); 2416 memset (pending_list, 0, 2417 hdr->ifdMax * sizeof (struct mdebug_pending *)); 2418 2419 /* Pass 0 over external syms: swap them in. */ 2420 ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR)); 2421 make_cleanup (xfree, ext_block); 2422 2423 ext_out = (char *) debug_info->external_ext; 2424 ext_out_end = ext_out + hdr->iextMax * external_ext_size; 2425 ext_in = ext_block; 2426 for (; ext_out < ext_out_end; ext_out += external_ext_size, ext_in++) 2427 (*swap_ext_in) (cur_bfd, ext_out, ext_in); 2428 2429 /* Pass 1 over external syms: Presize and partition the list */ 2430 ext_in = ext_block; 2431 ext_in_end = ext_in + hdr->iextMax; 2432 for (; ext_in < ext_in_end; ext_in++) 2433 { 2434 /* See calls to complain below. */ 2435 if (ext_in->ifd >= -1 2436 && ext_in->ifd < hdr->ifdMax 2437 && ext_in->asym.iss >= 0 2438 && ext_in->asym.iss < hdr->issExtMax) 2439 fdr_to_pst[ext_in->ifd].n_globals++; 2440 } 2441 2442 /* Pass 1.5 over files: partition out global symbol space */ 2443 s_idx = 0; 2444 for (f_idx = -1; f_idx < hdr->ifdMax; f_idx++) 2445 { 2446 fdr_to_pst[f_idx].globals_offset = s_idx; 2447 s_idx += fdr_to_pst[f_idx].n_globals; 2448 fdr_to_pst[f_idx].n_globals = 0; 2449 } 2450 2451 /* ECOFF in ELF: 2452 2453 For ECOFF in ELF, we skip the creation of the minimal symbols. 2454 The ECOFF symbols should be a subset of the Elf symbols, and the 2455 section information of the elf symbols will be more accurate. 2456 FIXME! What about Irix 5's native linker? 2457 2458 By default, Elf sections which don't exist in ECOFF 2459 get put in ECOFF's absolute section by the gnu linker. 2460 Since absolute sections don't get relocated, we 2461 end up calculating an address different from that of 2462 the symbol's minimal symbol (created earlier from the 2463 Elf symtab). 2464 2465 To fix this, either : 2466 1) don't create the duplicate symbol 2467 (assumes ECOFF symtab is a subset of the ELF symtab; 2468 assumes no side-effects result from ignoring ECOFF symbol) 2469 2) create it, only if lookup for existing symbol in ELF's minimal 2470 symbols fails 2471 (inefficient; 2472 assumes no side-effects result from ignoring ECOFF symbol) 2473 3) create it, but lookup ELF's minimal symbol and use it's section 2474 during relocation, then modify "uniqify" phase to merge and 2475 eliminate the duplicate symbol 2476 (highly inefficient) 2477 2478 I've implemented #1 here... 2479 Skip the creation of the minimal symbols based on the ECOFF 2480 symbol table. */ 2481 2482 /* Pass 2 over external syms: fill in external symbols */ 2483 ext_in = ext_block; 2484 ext_in_end = ext_in + hdr->iextMax; 2485 for (; ext_in < ext_in_end; ext_in++) 2486 { 2487 enum minimal_symbol_type ms_type = mst_text; 2488 CORE_ADDR svalue = ext_in->asym.value; 2489 2490 /* The Irix 5 native tools seem to sometimes generate bogus 2491 external symbols. */ 2492 if (ext_in->ifd < -1 || ext_in->ifd >= hdr->ifdMax) 2493 { 2494 complaint (&symfile_complaints, 2495 _("bad ifd for external symbol: %d (max %ld)"), ext_in->ifd, 2496 hdr->ifdMax); 2497 continue; 2498 } 2499 if (ext_in->asym.iss < 0 || ext_in->asym.iss >= hdr->issExtMax) 2500 { 2501 complaint (&symfile_complaints, 2502 _("bad iss for external symbol: %ld (max %ld)"), 2503 ext_in->asym.iss, hdr->issExtMax); 2504 continue; 2505 } 2506 2507 extern_tab[fdr_to_pst[ext_in->ifd].globals_offset 2508 + fdr_to_pst[ext_in->ifd].n_globals++] = *ext_in; 2509 2510 2511 if (SC_IS_UNDEF (ext_in->asym.sc) || ext_in->asym.sc == scNil) 2512 continue; 2513 2514 2515 /* Pass 3 over files, over local syms: fill in static symbols */ 2516 name = debug_info->ssext + ext_in->asym.iss; 2517 2518 /* Process ECOFF Symbol Types and Storage Classes */ 2519 switch (ext_in->asym.st) 2520 { 2521 case stProc: 2522 /* Beginnning of Procedure */ 2523 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2524 break; 2525 case stStaticProc: 2526 /* Load time only static procs */ 2527 ms_type = mst_file_text; 2528 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2529 break; 2530 case stGlobal: 2531 /* External symbol */ 2532 if (SC_IS_COMMON (ext_in->asym.sc)) 2533 { 2534 /* The value of a common symbol is its size, not its address. 2535 Ignore it. */ 2536 continue; 2537 } 2538 else if (SC_IS_DATA (ext_in->asym.sc)) 2539 { 2540 ms_type = mst_data; 2541 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 2542 } 2543 else if (SC_IS_BSS (ext_in->asym.sc)) 2544 { 2545 ms_type = mst_bss; 2546 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 2547 } 2548 else if (SC_IS_SBSS (ext_in->asym.sc)) 2549 { 2550 ms_type = mst_bss; 2551 svalue += ANOFFSET (objfile->section_offsets, 2552 get_section_index (objfile, ".sbss")); 2553 } 2554 else 2555 ms_type = mst_abs; 2556 break; 2557 case stLabel: 2558 /* Label */ 2559 2560 /* On certain platforms, some extra label symbols can be 2561 generated by the linker. One possible usage for this kind 2562 of symbols is to represent the address of the begining of a 2563 given section. For instance, on Tru64 5.1, the address of 2564 the _ftext label is the start address of the .text section. 2565 2566 The storage class of these symbols is usually directly 2567 related to the section to which the symbol refers. For 2568 instance, on Tru64 5.1, the storage class for the _fdata 2569 label is scData, refering to the .data section. 2570 2571 It is actually possible that the section associated to the 2572 storage class of the label does not exist. On True64 5.1 2573 for instance, the libm.so shared library does not contain 2574 any .data section, although it contains a _fpdata label 2575 which storage class is scData... Since these symbols are 2576 usually useless for the debugger user anyway, we just 2577 discard these symbols. 2578 */ 2579 2580 if (SC_IS_TEXT (ext_in->asym.sc)) 2581 { 2582 if (objfile->sect_index_text == -1) 2583 continue; 2584 2585 ms_type = mst_file_text; 2586 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2587 } 2588 else if (SC_IS_DATA (ext_in->asym.sc)) 2589 { 2590 if (objfile->sect_index_data == -1) 2591 continue; 2592 2593 ms_type = mst_file_data; 2594 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 2595 } 2596 else if (SC_IS_BSS (ext_in->asym.sc)) 2597 { 2598 if (objfile->sect_index_bss == -1) 2599 continue; 2600 2601 ms_type = mst_file_bss; 2602 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 2603 } 2604 else if (SC_IS_SBSS (ext_in->asym.sc)) 2605 { 2606 const int sbss_sect_index = get_section_index (objfile, ".sbss"); 2607 2608 if (sbss_sect_index == -1) 2609 continue; 2610 2611 ms_type = mst_file_bss; 2612 svalue += ANOFFSET (objfile->section_offsets, sbss_sect_index); 2613 } 2614 else 2615 ms_type = mst_abs; 2616 break; 2617 case stLocal: 2618 case stNil: 2619 /* The alpha has the section start addresses in stLocal symbols 2620 whose name starts with a `.'. Skip those but complain for all 2621 other stLocal symbols. 2622 Irix6 puts the section start addresses in stNil symbols, skip 2623 those too. */ 2624 if (name[0] == '.') 2625 continue; 2626 /* Fall through. */ 2627 default: 2628 ms_type = mst_unknown; 2629 unknown_ext_complaint (name); 2630 } 2631 if (!ECOFF_IN_ELF (cur_bfd)) 2632 record_minimal_symbol (name, svalue, ms_type, ext_in->asym.sc, 2633 objfile); 2634 } 2635 2636 /* Pass 3 over files, over local syms: fill in static symbols */ 2637 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) 2638 { 2639 struct partial_symtab *save_pst; 2640 EXTR *ext_ptr; 2641 CORE_ADDR textlow; 2642 2643 cur_fdr = fh = debug_info->fdr + f_idx; 2644 2645 if (fh->csym == 0) 2646 { 2647 fdr_to_pst[f_idx].pst = NULL; 2648 continue; 2649 } 2650 2651 /* Determine the start address for this object file from the 2652 file header and relocate it, except for Irix 5.2 zero fh->adr. */ 2653 if (fh->cpd) 2654 { 2655 textlow = fh->adr; 2656 if (relocatable || textlow != 0) 2657 textlow += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2658 } 2659 else 2660 textlow = 0; 2661 pst = start_psymtab_common (objfile, objfile->section_offsets, 2662 fdr_name (fh), 2663 textlow, 2664 objfile->global_psymbols.next, 2665 objfile->static_psymbols.next); 2666 pst->read_symtab_private = ((char *) 2667 obstack_alloc (&objfile->objfile_obstack, 2668 sizeof (struct symloc))); 2669 memset (pst->read_symtab_private, 0, sizeof (struct symloc)); 2670 2671 save_pst = pst; 2672 FDR_IDX (pst) = f_idx; 2673 CUR_BFD (pst) = cur_bfd; 2674 DEBUG_SWAP (pst) = debug_swap; 2675 DEBUG_INFO (pst) = debug_info; 2676 PENDING_LIST (pst) = pending_list; 2677 2678 /* The way to turn this into a symtab is to call... */ 2679 pst->read_symtab = mdebug_psymtab_to_symtab; 2680 2681 /* Set up language for the pst. 2682 The language from the FDR is used if it is unambigious (e.g. cfront 2683 with native cc and g++ will set the language to C). 2684 Otherwise we have to deduce the language from the filename. 2685 Native ecoff has every header file in a separate FDR, so 2686 deduce_language_from_filename will return language_unknown for 2687 a header file, which is not what we want. 2688 But the FDRs for the header files are after the FDR for the source 2689 file, so we can assign the language of the source file to the 2690 following header files. Then we save the language in the private 2691 pst data so that we can reuse it when building symtabs. */ 2692 prev_language = psymtab_language; 2693 2694 switch (fh->lang) 2695 { 2696 case langCplusplusV2: 2697 psymtab_language = language_cplus; 2698 break; 2699 default: 2700 psymtab_language = deduce_language_from_filename (fdr_name (fh)); 2701 break; 2702 } 2703 if (psymtab_language == language_unknown) 2704 psymtab_language = prev_language; 2705 PST_PRIVATE (pst)->pst_language = psymtab_language; 2706 2707 pst->texthigh = pst->textlow; 2708 2709 /* For stabs-in-ecoff files, the second symbol must be @stab. 2710 This symbol is emitted by mips-tfile to signal that the 2711 current object file uses encapsulated stabs instead of mips 2712 ecoff for local symbols. (It is the second symbol because 2713 the first symbol is the stFile used to signal the start of a 2714 file). */ 2715 processing_gcc_compilation = 0; 2716 if (fh->csym >= 2) 2717 { 2718 (*swap_sym_in) (cur_bfd, 2719 ((char *) debug_info->external_sym 2720 + (fh->isymBase + 1) * external_sym_size), 2721 &sh); 2722 if (strcmp (debug_info->ss + fh->issBase + sh.iss, 2723 stabs_symbol) == 0) 2724 processing_gcc_compilation = 2; 2725 } 2726 2727 if (processing_gcc_compilation != 0) 2728 { 2729 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++) 2730 { 2731 int type_code; 2732 char *namestring; 2733 2734 (*swap_sym_in) (cur_bfd, 2735 (((char *) debug_info->external_sym) 2736 + (fh->isymBase + cur_sdx) * external_sym_size), 2737 &sh); 2738 type_code = ECOFF_UNMARK_STAB (sh.index); 2739 if (!ECOFF_IS_STAB (&sh)) 2740 { 2741 if (sh.st == stProc || sh.st == stStaticProc) 2742 { 2743 CORE_ADDR procaddr; 2744 long isym; 2745 2746 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2747 if (sh.st == stStaticProc) 2748 { 2749 namestring = debug_info->ss + fh->issBase + sh.iss; 2750 record_minimal_symbol (namestring, sh.value, 2751 mst_file_text, sh.sc, 2752 objfile); 2753 } 2754 procaddr = sh.value; 2755 2756 isym = AUX_GET_ISYM (fh->fBigendian, 2757 (debug_info->external_aux 2758 + fh->iauxBase 2759 + sh.index)); 2760 (*swap_sym_in) (cur_bfd, 2761 ((char *) debug_info->external_sym 2762 + ((fh->isymBase + isym - 1) 2763 * external_sym_size)), 2764 &sh); 2765 if (sh.st == stEnd) 2766 { 2767 CORE_ADDR high = procaddr + sh.value; 2768 2769 /* Kludge for Irix 5.2 zero fh->adr. */ 2770 if (!relocatable 2771 && (pst->textlow == 0 || procaddr < pst->textlow)) 2772 pst->textlow = procaddr; 2773 if (high > pst->texthigh) 2774 pst->texthigh = high; 2775 } 2776 } 2777 else if (sh.st == stStatic) 2778 { 2779 switch (sh.sc) 2780 { 2781 case scUndefined: 2782 case scSUndefined: 2783 case scNil: 2784 case scAbs: 2785 break; 2786 2787 case scData: 2788 case scSData: 2789 case scRData: 2790 case scPData: 2791 case scXData: 2792 namestring = debug_info->ss + fh->issBase + sh.iss; 2793 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 2794 record_minimal_symbol (namestring, sh.value, 2795 mst_file_data, sh.sc, 2796 objfile); 2797 break; 2798 2799 default: 2800 /* FIXME! Shouldn't this use cases for bss, 2801 then have the default be abs? */ 2802 namestring = debug_info->ss + fh->issBase + sh.iss; 2803 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 2804 record_minimal_symbol (namestring, sh.value, 2805 mst_file_bss, sh.sc, 2806 objfile); 2807 break; 2808 } 2809 } 2810 continue; 2811 } 2812 /* Handle stabs continuation */ 2813 { 2814 char *stabstring = debug_info->ss + fh->issBase + sh.iss; 2815 int len = strlen (stabstring); 2816 while (stabstring[len - 1] == '\\') 2817 { 2818 SYMR sh2; 2819 char *stabstring1 = stabstring; 2820 char *stabstring2; 2821 int len2; 2822 2823 /* Ignore continuation char from 1st string */ 2824 len--; 2825 2826 /* Read next stabstring */ 2827 cur_sdx++; 2828 (*swap_sym_in) (cur_bfd, 2829 (((char *) debug_info->external_sym) 2830 + (fh->isymBase + cur_sdx) 2831 * external_sym_size), 2832 &sh2); 2833 stabstring2 = debug_info->ss + fh->issBase + sh2.iss; 2834 len2 = strlen (stabstring2); 2835 2836 /* Concatinate stabstring2 with stabstring1 */ 2837 if (stabstring 2838 && stabstring != debug_info->ss + fh->issBase + sh.iss) 2839 stabstring = xrealloc (stabstring, len + len2 + 1); 2840 else 2841 { 2842 stabstring = xmalloc (len + len2 + 1); 2843 strcpy (stabstring, stabstring1); 2844 } 2845 strcpy (stabstring + len, stabstring2); 2846 len += len2; 2847 } 2848 2849 switch (type_code) 2850 { 2851 char *p; 2852 /* 2853 * Standard, external, non-debugger, symbols 2854 */ 2855 2856 case N_TEXT | N_EXT: 2857 case N_NBTEXT | N_EXT: 2858 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2859 goto record_it; 2860 2861 case N_DATA | N_EXT: 2862 case N_NBDATA | N_EXT: 2863 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 2864 goto record_it; 2865 2866 case N_BSS: 2867 case N_BSS | N_EXT: 2868 case N_NBBSS | N_EXT: 2869 case N_SETV | N_EXT: /* FIXME, is this in BSS? */ 2870 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 2871 goto record_it; 2872 2873 case N_ABS | N_EXT: 2874 record_it: 2875 continue; 2876 2877 /* Standard, local, non-debugger, symbols */ 2878 2879 case N_NBTEXT: 2880 2881 /* We need to be able to deal with both N_FN or N_TEXT, 2882 because we have no way of knowing whether the sys-supplied ld 2883 or GNU ld was used to make the executable. Sequents throw 2884 in another wrinkle -- they renumbered N_FN. */ 2885 2886 case N_FN: 2887 case N_FN_SEQ: 2888 case N_TEXT: 2889 continue; 2890 2891 case N_DATA: 2892 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 2893 goto record_it; 2894 2895 case N_UNDF | N_EXT: 2896 continue; /* Just undefined, not COMMON */ 2897 2898 case N_UNDF: 2899 continue; 2900 2901 /* Lots of symbol types we can just ignore. */ 2902 2903 case N_ABS: 2904 case N_NBDATA: 2905 case N_NBBSS: 2906 continue; 2907 2908 /* Keep going . . . */ 2909 2910 /* 2911 * Special symbol types for GNU 2912 */ 2913 case N_INDR: 2914 case N_INDR | N_EXT: 2915 case N_SETA: 2916 case N_SETA | N_EXT: 2917 case N_SETT: 2918 case N_SETT | N_EXT: 2919 case N_SETD: 2920 case N_SETD | N_EXT: 2921 case N_SETB: 2922 case N_SETB | N_EXT: 2923 case N_SETV: 2924 continue; 2925 2926 /* 2927 * Debugger symbols 2928 */ 2929 2930 case N_SO: 2931 { 2932 CORE_ADDR valu; 2933 static int prev_so_symnum = -10; 2934 static int first_so_symnum; 2935 char *p; 2936 int prev_textlow_not_set; 2937 2938 valu = sh.value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 2939 2940 prev_textlow_not_set = textlow_not_set; 2941 2942 /* A zero value is probably an indication for the SunPRO 3.0 2943 compiler. end_psymtab explicitly tests for zero, so 2944 don't relocate it. */ 2945 2946 if (sh.value == 0 2947 && gdbarch_sofun_address_maybe_missing (gdbarch)) 2948 { 2949 textlow_not_set = 1; 2950 valu = 0; 2951 } 2952 else 2953 textlow_not_set = 0; 2954 2955 past_first_source_file = 1; 2956 2957 if (prev_so_symnum != symnum - 1) 2958 { /* Here if prev stab wasn't N_SO */ 2959 first_so_symnum = symnum; 2960 2961 if (pst) 2962 { 2963 pst = (struct partial_symtab *) 0; 2964 includes_used = 0; 2965 dependencies_used = 0; 2966 } 2967 } 2968 2969 prev_so_symnum = symnum; 2970 2971 /* End the current partial symtab and start a new one */ 2972 2973 /* SET_NAMESTRING ();*/ 2974 namestring = stabstring; 2975 2976 /* Null name means end of .o file. Don't start a new one. */ 2977 if (*namestring == '\000') 2978 continue; 2979 2980 /* Some compilers (including gcc) emit a pair of initial N_SOs. 2981 The first one is a directory name; the second the file name. 2982 If pst exists, is empty, and has a filename ending in '/', 2983 we assume the previous N_SO was a directory name. */ 2984 2985 p = strrchr (namestring, '/'); 2986 if (p && *(p + 1) == '\000') 2987 continue; /* Simply ignore directory name SOs */ 2988 2989 /* Some other compilers (C++ ones in particular) emit useless 2990 SOs for non-existant .c files. We ignore all subsequent SOs that 2991 immediately follow the first. */ 2992 2993 if (!pst) 2994 pst = save_pst; 2995 continue; 2996 } 2997 2998 case N_BINCL: 2999 continue; 3000 3001 case N_SOL: 3002 { 3003 enum language tmp_language; 3004 /* Mark down an include file in the current psymtab */ 3005 3006 /* SET_NAMESTRING ();*/ 3007 namestring = stabstring; 3008 3009 tmp_language = deduce_language_from_filename (namestring); 3010 3011 /* Only change the psymtab's language if we've learned 3012 something useful (eg. tmp_language is not language_unknown). 3013 In addition, to match what start_subfile does, never change 3014 from C++ to C. */ 3015 if (tmp_language != language_unknown 3016 && (tmp_language != language_c 3017 || psymtab_language != language_cplus)) 3018 psymtab_language = tmp_language; 3019 3020 /* In C++, one may expect the same filename to come round many 3021 times, when code is coming alternately from the main file 3022 and from inline functions in other files. So I check to see 3023 if this is a file we've seen before -- either the main 3024 source file, or a previously included file. 3025 3026 This seems to be a lot of time to be spending on N_SOL, but 3027 things like "break c-exp.y:435" need to work (I 3028 suppose the psymtab_include_list could be hashed or put 3029 in a binary tree, if profiling shows this is a major hog). */ 3030 if (pst && strcmp (namestring, pst->filename) == 0) 3031 continue; 3032 { 3033 int i; 3034 for (i = 0; i < includes_used; i++) 3035 if (strcmp (namestring, 3036 psymtab_include_list[i]) == 0) 3037 { 3038 i = -1; 3039 break; 3040 } 3041 if (i == -1) 3042 continue; 3043 } 3044 3045 psymtab_include_list[includes_used++] = namestring; 3046 if (includes_used >= includes_allocated) 3047 { 3048 char **orig = psymtab_include_list; 3049 3050 psymtab_include_list = (char **) 3051 alloca ((includes_allocated *= 2) * 3052 sizeof (char *)); 3053 memcpy (psymtab_include_list, orig, 3054 includes_used * sizeof (char *)); 3055 } 3056 continue; 3057 } 3058 case N_LSYM: /* Typedef or automatic variable. */ 3059 case N_STSYM: /* Data seg var -- static */ 3060 case N_LCSYM: /* BSS " */ 3061 case N_ROSYM: /* Read-only data seg var -- static. */ 3062 case N_NBSTS: /* Gould nobase. */ 3063 case N_NBLCS: /* symbols. */ 3064 case N_FUN: 3065 case N_GSYM: /* Global (extern) variable; can be 3066 data or bss (sigh FIXME). */ 3067 3068 /* Following may probably be ignored; I'll leave them here 3069 for now (until I do Pascal and Modula 2 extensions). */ 3070 3071 case N_PC: /* I may or may not need this; I 3072 suspect not. */ 3073 case N_M2C: /* I suspect that I can ignore this here. */ 3074 case N_SCOPE: /* Same. */ 3075 3076 /* SET_NAMESTRING ();*/ 3077 namestring = stabstring; 3078 p = (char *) strchr (namestring, ':'); 3079 if (!p) 3080 continue; /* Not a debugging symbol. */ 3081 3082 3083 3084 /* Main processing section for debugging symbols which 3085 the initial read through the symbol tables needs to worry 3086 about. If we reach this point, the symbol which we are 3087 considering is definitely one we are interested in. 3088 p must also contain the (valid) index into the namestring 3089 which indicates the debugging type symbol. */ 3090 3091 switch (p[1]) 3092 { 3093 case 'S': 3094 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 3095 3096 if (gdbarch_static_transform_name_p (gdbarch)) 3097 namestring = gdbarch_static_transform_name 3098 (gdbarch, namestring); 3099 3100 add_psymbol_to_list (namestring, p - namestring, 3101 VAR_DOMAIN, LOC_STATIC, 3102 &objfile->static_psymbols, 3103 0, sh.value, 3104 psymtab_language, objfile); 3105 continue; 3106 case 'G': 3107 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 3108 /* The addresses in these entries are reported to be 3109 wrong. See the code that reads 'G's for symtabs. */ 3110 add_psymbol_to_list (namestring, p - namestring, 3111 VAR_DOMAIN, LOC_STATIC, 3112 &objfile->global_psymbols, 3113 0, sh.value, 3114 psymtab_language, objfile); 3115 continue; 3116 3117 case 'T': 3118 /* When a 'T' entry is defining an anonymous enum, it 3119 may have a name which is the empty string, or a 3120 single space. Since they're not really defining a 3121 symbol, those shouldn't go in the partial symbol 3122 table. We do pick up the elements of such enums at 3123 'check_enum:', below. */ 3124 if (p >= namestring + 2 3125 || (p == namestring + 1 3126 && namestring[0] != ' ')) 3127 { 3128 add_psymbol_to_list (namestring, p - namestring, 3129 STRUCT_DOMAIN, LOC_TYPEDEF, 3130 &objfile->static_psymbols, 3131 sh.value, 0, 3132 psymtab_language, objfile); 3133 if (p[2] == 't') 3134 { 3135 /* Also a typedef with the same name. */ 3136 add_psymbol_to_list (namestring, p - namestring, 3137 VAR_DOMAIN, LOC_TYPEDEF, 3138 &objfile->static_psymbols, 3139 sh.value, 0, 3140 psymtab_language, objfile); 3141 p += 1; 3142 } 3143 } 3144 goto check_enum; 3145 case 't': 3146 if (p != namestring) /* a name is there, not just :T... */ 3147 { 3148 add_psymbol_to_list (namestring, p - namestring, 3149 VAR_DOMAIN, LOC_TYPEDEF, 3150 &objfile->static_psymbols, 3151 sh.value, 0, 3152 psymtab_language, objfile); 3153 } 3154 check_enum: 3155 /* If this is an enumerated type, we need to 3156 add all the enum constants to the partial symbol 3157 table. This does not cover enums without names, e.g. 3158 "enum {a, b} c;" in C, but fortunately those are 3159 rare. There is no way for GDB to find those from the 3160 enum type without spending too much time on it. Thus 3161 to solve this problem, the compiler needs to put out the 3162 enum in a nameless type. GCC2 does this. */ 3163 3164 /* We are looking for something of the form 3165 <name> ":" ("t" | "T") [<number> "="] "e" 3166 {<constant> ":" <value> ","} ";". */ 3167 3168 /* Skip over the colon and the 't' or 'T'. */ 3169 p += 2; 3170 /* This type may be given a number. Also, numbers can come 3171 in pairs like (0,26). Skip over it. */ 3172 while ((*p >= '0' && *p <= '9') 3173 || *p == '(' || *p == ',' || *p == ')' 3174 || *p == '=') 3175 p++; 3176 3177 if (*p++ == 'e') 3178 { 3179 /* The aix4 compiler emits extra crud before the members. */ 3180 if (*p == '-') 3181 { 3182 /* Skip over the type (?). */ 3183 while (*p != ':') 3184 p++; 3185 3186 /* Skip over the colon. */ 3187 p++; 3188 } 3189 3190 /* We have found an enumerated type. */ 3191 /* According to comments in read_enum_type 3192 a comma could end it instead of a semicolon. 3193 I don't know where that happens. 3194 Accept either. */ 3195 while (*p && *p != ';' && *p != ',') 3196 { 3197 char *q; 3198 3199 /* Check for and handle cretinous dbx symbol name 3200 continuation! */ 3201 if (*p == '\\' || (*p == '?' && p[1] == '\0')) 3202 p = next_symbol_text (objfile); 3203 3204 /* Point to the character after the name 3205 of the enum constant. */ 3206 for (q = p; *q && *q != ':'; q++) 3207 ; 3208 /* Note that the value doesn't matter for 3209 enum constants in psymtabs, just in symtabs. */ 3210 add_psymbol_to_list (p, q - p, 3211 VAR_DOMAIN, LOC_CONST, 3212 &objfile->static_psymbols, 0, 3213 0, psymtab_language, objfile); 3214 /* Point past the name. */ 3215 p = q; 3216 /* Skip over the value. */ 3217 while (*p && *p != ',') 3218 p++; 3219 /* Advance past the comma. */ 3220 if (*p) 3221 p++; 3222 } 3223 } 3224 continue; 3225 case 'c': 3226 /* Constant, e.g. from "const" in Pascal. */ 3227 add_psymbol_to_list (namestring, p - namestring, 3228 VAR_DOMAIN, LOC_CONST, 3229 &objfile->static_psymbols, sh.value, 3230 0, psymtab_language, objfile); 3231 continue; 3232 3233 case 'f': 3234 if (! pst) 3235 { 3236 int name_len = p - namestring; 3237 char *name = xmalloc (name_len + 1); 3238 memcpy (name, namestring, name_len); 3239 name[name_len] = '\0'; 3240 function_outside_compilation_unit_complaint (name); 3241 xfree (name); 3242 } 3243 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 3244 add_psymbol_to_list (namestring, p - namestring, 3245 VAR_DOMAIN, LOC_BLOCK, 3246 &objfile->static_psymbols, 3247 0, sh.value, 3248 psymtab_language, objfile); 3249 continue; 3250 3251 /* Global functions were ignored here, but now they 3252 are put into the global psymtab like one would expect. 3253 They're also in the minimal symbol table. */ 3254 case 'F': 3255 if (! pst) 3256 { 3257 int name_len = p - namestring; 3258 char *name = xmalloc (name_len + 1); 3259 memcpy (name, namestring, name_len); 3260 name[name_len] = '\0'; 3261 function_outside_compilation_unit_complaint (name); 3262 xfree (name); 3263 } 3264 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 3265 add_psymbol_to_list (namestring, p - namestring, 3266 VAR_DOMAIN, LOC_BLOCK, 3267 &objfile->global_psymbols, 3268 0, sh.value, 3269 psymtab_language, objfile); 3270 continue; 3271 3272 /* Two things show up here (hopefully); static symbols of 3273 local scope (static used inside braces) or extensions 3274 of structure symbols. We can ignore both. */ 3275 case 'V': 3276 case '(': 3277 case '0': 3278 case '1': 3279 case '2': 3280 case '3': 3281 case '4': 3282 case '5': 3283 case '6': 3284 case '7': 3285 case '8': 3286 case '9': 3287 case '-': 3288 case '#': /* for symbol identification (used in live ranges) */ 3289 continue; 3290 3291 case ':': 3292 /* It is a C++ nested symbol. We don't need to record it 3293 (I don't think); if we try to look up foo::bar::baz, 3294 then symbols for the symtab containing foo should get 3295 read in, I think. */ 3296 /* Someone says sun cc puts out symbols like 3297 /foo/baz/maclib::/usr/local/bin/maclib, 3298 which would get here with a symbol type of ':'. */ 3299 continue; 3300 3301 default: 3302 /* Unexpected symbol descriptor. The second and subsequent stabs 3303 of a continued stab can show up here. The question is 3304 whether they ever can mimic a normal stab--it would be 3305 nice if not, since we certainly don't want to spend the 3306 time searching to the end of every string looking for 3307 a backslash. */ 3308 3309 complaint (&symfile_complaints, 3310 _("unknown symbol descriptor `%c'"), p[1]); 3311 3312 /* Ignore it; perhaps it is an extension that we don't 3313 know about. */ 3314 continue; 3315 } 3316 3317 case N_EXCL: 3318 continue; 3319 3320 case N_ENDM: 3321 /* Solaris 2 end of module, finish current partial 3322 symbol table. END_PSYMTAB will set 3323 pst->texthigh to the proper value, which is 3324 necessary if a module compiled without 3325 debugging info follows this module. */ 3326 if (pst 3327 && gdbarch_sofun_address_maybe_missing (gdbarch)) 3328 { 3329 pst = (struct partial_symtab *) 0; 3330 includes_used = 0; 3331 dependencies_used = 0; 3332 } 3333 continue; 3334 3335 case N_RBRAC: 3336 if (sh.value > save_pst->texthigh) 3337 save_pst->texthigh = sh.value; 3338 continue; 3339 case N_EINCL: 3340 case N_DSLINE: 3341 case N_BSLINE: 3342 case N_SSYM: /* Claim: Structure or union element. 3343 Hopefully, I can ignore this. */ 3344 case N_ENTRY: /* Alternate entry point; can ignore. */ 3345 case N_MAIN: /* Can definitely ignore this. */ 3346 case N_CATCH: /* These are GNU C++ extensions */ 3347 case N_EHDECL: /* that can safely be ignored here. */ 3348 case N_LENG: 3349 case N_BCOMM: 3350 case N_ECOMM: 3351 case N_ECOML: 3352 case N_FNAME: 3353 case N_SLINE: 3354 case N_RSYM: 3355 case N_PSYM: 3356 case N_LBRAC: 3357 case N_NSYMS: /* Ultrix 4.0: symbol count */ 3358 case N_DEFD: /* GNU Modula-2 */ 3359 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */ 3360 3361 case N_OBJ: /* useless types from Solaris */ 3362 case N_OPT: 3363 /* These symbols aren't interesting; don't worry about them */ 3364 3365 continue; 3366 3367 default: 3368 /* If we haven't found it yet, ignore it. It's probably some 3369 new type we don't know about yet. */ 3370 complaint (&symfile_complaints, _("unknown symbol type %s"), 3371 hex_string (type_code)); /*CUR_SYMBOL_TYPE*/ 3372 continue; 3373 } 3374 if (stabstring 3375 && stabstring != debug_info->ss + fh->issBase + sh.iss) 3376 xfree (stabstring); 3377 } 3378 /* end - Handle continuation */ 3379 } 3380 } 3381 else 3382 { 3383 for (cur_sdx = 0; cur_sdx < fh->csym;) 3384 { 3385 char *name; 3386 enum address_class class; 3387 3388 (*swap_sym_in) (cur_bfd, 3389 ((char *) debug_info->external_sym 3390 + ((fh->isymBase + cur_sdx) 3391 * external_sym_size)), 3392 &sh); 3393 3394 if (ECOFF_IS_STAB (&sh)) 3395 { 3396 cur_sdx++; 3397 continue; 3398 } 3399 3400 /* Non absolute static symbols go into the minimal table. */ 3401 if (SC_IS_UNDEF (sh.sc) || sh.sc == scNil 3402 || (sh.index == indexNil 3403 && (sh.st != stStatic || sh.sc == scAbs))) 3404 { 3405 /* FIXME, premature? */ 3406 cur_sdx++; 3407 continue; 3408 } 3409 3410 name = debug_info->ss + fh->issBase + sh.iss; 3411 3412 switch (sh.sc) 3413 { 3414 case scText: 3415 case scRConst: 3416 /* The value of a stEnd symbol is the displacement from the 3417 corresponding start symbol value, do not relocate it. */ 3418 if (sh.st != stEnd) 3419 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 3420 break; 3421 case scData: 3422 case scSData: 3423 case scRData: 3424 case scPData: 3425 case scXData: 3426 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 3427 break; 3428 case scBss: 3429 case scSBss: 3430 sh.value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 3431 break; 3432 } 3433 3434 switch (sh.st) 3435 { 3436 CORE_ADDR high; 3437 CORE_ADDR procaddr; 3438 int new_sdx; 3439 3440 case stStaticProc: 3441 prim_record_minimal_symbol_and_info (name, sh.value, 3442 mst_file_text, 3443 SECT_OFF_TEXT (objfile), NULL, 3444 objfile); 3445 3446 /* FALLTHROUGH */ 3447 3448 case stProc: 3449 /* Ignore all parameter symbol records. */ 3450 if (sh.index >= hdr->iauxMax) 3451 { 3452 /* Should not happen, but does when cross-compiling 3453 with the MIPS compiler. FIXME -- pull later. */ 3454 index_complaint (name); 3455 new_sdx = cur_sdx + 1; /* Don't skip at all */ 3456 } 3457 else 3458 new_sdx = AUX_GET_ISYM (fh->fBigendian, 3459 (debug_info->external_aux 3460 + fh->iauxBase 3461 + sh.index)); 3462 3463 if (new_sdx <= cur_sdx) 3464 { 3465 /* This should not happen either... FIXME. */ 3466 complaint (&symfile_complaints, 3467 _("bad proc end in aux found from symbol %s"), 3468 name); 3469 new_sdx = cur_sdx + 1; /* Don't skip backward */ 3470 } 3471 3472 /* For stProc symbol records, we need to check the 3473 storage class as well, as only (stProc, scText) 3474 entries represent "real" procedures - See the 3475 Compaq document titled "Object File / Symbol Table 3476 Format Specification" for more information. If the 3477 storage class is not scText, we discard the whole 3478 block of symbol records for this stProc. */ 3479 if (sh.st == stProc && sh.sc != scText) 3480 goto skip; 3481 3482 /* Usually there is a local and a global stProc symbol 3483 for a function. This means that the function name 3484 has already been entered into the mimimal symbol table 3485 while processing the global symbols in pass 2 above. 3486 One notable exception is the PROGRAM name from 3487 f77 compiled executables, it is only put out as 3488 local stProc symbol, and a global MAIN__ stProc symbol 3489 points to it. It doesn't matter though, as gdb is 3490 still able to find the PROGRAM name via the partial 3491 symbol table, and the MAIN__ symbol via the minimal 3492 symbol table. */ 3493 if (sh.st == stProc) 3494 add_psymbol_to_list (name, strlen (name), 3495 VAR_DOMAIN, LOC_BLOCK, 3496 &objfile->global_psymbols, 3497 0, sh.value, psymtab_language, objfile); 3498 else 3499 add_psymbol_to_list (name, strlen (name), 3500 VAR_DOMAIN, LOC_BLOCK, 3501 &objfile->static_psymbols, 3502 0, sh.value, psymtab_language, objfile); 3503 3504 procaddr = sh.value; 3505 3506 cur_sdx = new_sdx; 3507 (*swap_sym_in) (cur_bfd, 3508 ((char *) debug_info->external_sym 3509 + ((fh->isymBase + cur_sdx - 1) 3510 * external_sym_size)), 3511 &sh); 3512 if (sh.st != stEnd) 3513 continue; 3514 3515 /* Kludge for Irix 5.2 zero fh->adr. */ 3516 if (!relocatable 3517 && (pst->textlow == 0 || procaddr < pst->textlow)) 3518 pst->textlow = procaddr; 3519 3520 high = procaddr + sh.value; 3521 if (high > pst->texthigh) 3522 pst->texthigh = high; 3523 continue; 3524 3525 case stStatic: /* Variable */ 3526 if (SC_IS_DATA (sh.sc)) 3527 prim_record_minimal_symbol_and_info (name, sh.value, 3528 mst_file_data, 3529 SECT_OFF_DATA (objfile), 3530 NULL, 3531 objfile); 3532 else 3533 prim_record_minimal_symbol_and_info (name, sh.value, 3534 mst_file_bss, 3535 SECT_OFF_BSS (objfile), 3536 NULL, 3537 objfile); 3538 class = LOC_STATIC; 3539 break; 3540 3541 case stIndirect: /* Irix5 forward declaration */ 3542 /* Skip forward declarations from Irix5 cc */ 3543 goto skip; 3544 3545 case stTypedef: /* Typedef */ 3546 /* Skip typedefs for forward declarations and opaque 3547 structs from alpha and mips cc. */ 3548 if (sh.iss == 0 || has_opaque_xref (fh, &sh)) 3549 goto skip; 3550 class = LOC_TYPEDEF; 3551 break; 3552 3553 case stConstant: /* Constant decl */ 3554 class = LOC_CONST; 3555 break; 3556 3557 case stUnion: 3558 case stStruct: 3559 case stEnum: 3560 case stBlock: /* { }, str, un, enum */ 3561 /* Do not create a partial symbol for cc unnamed aggregates 3562 and gcc empty aggregates. */ 3563 if ((sh.sc == scInfo 3564 || SC_IS_COMMON (sh.sc)) 3565 && sh.iss != 0 3566 && sh.index != cur_sdx + 2) 3567 { 3568 add_psymbol_to_list (name, strlen (name), 3569 STRUCT_DOMAIN, LOC_TYPEDEF, 3570 &objfile->static_psymbols, 3571 0, (CORE_ADDR) 0, 3572 psymtab_language, objfile); 3573 } 3574 handle_psymbol_enumerators (objfile, fh, sh.st, sh.value); 3575 3576 /* Skip over the block */ 3577 new_sdx = sh.index; 3578 if (new_sdx <= cur_sdx) 3579 { 3580 /* This happens with the Ultrix kernel. */ 3581 complaint (&symfile_complaints, 3582 _("bad aux index at block symbol %s"), name); 3583 new_sdx = cur_sdx + 1; /* Don't skip backward */ 3584 } 3585 cur_sdx = new_sdx; 3586 continue; 3587 3588 case stFile: /* File headers */ 3589 case stLabel: /* Labels */ 3590 case stEnd: /* Ends of files */ 3591 goto skip; 3592 3593 case stLocal: /* Local variables */ 3594 /* Normally these are skipped because we skip over 3595 all blocks we see. However, these can occur 3596 as visible symbols in a .h file that contains code. */ 3597 goto skip; 3598 3599 default: 3600 /* Both complaints are valid: one gives symbol name, 3601 the other the offending symbol type. */ 3602 complaint (&symfile_complaints, _("unknown local symbol %s"), 3603 name); 3604 complaint (&symfile_complaints, _("with type %d"), sh.st); 3605 cur_sdx++; 3606 continue; 3607 } 3608 /* Use this gdb symbol */ 3609 add_psymbol_to_list (name, strlen (name), 3610 VAR_DOMAIN, class, 3611 &objfile->static_psymbols, 3612 0, sh.value, psymtab_language, objfile); 3613 skip: 3614 cur_sdx++; /* Go to next file symbol */ 3615 } 3616 3617 /* Now do enter the external symbols. */ 3618 ext_ptr = &extern_tab[fdr_to_pst[f_idx].globals_offset]; 3619 cur_sdx = fdr_to_pst[f_idx].n_globals; 3620 PST_PRIVATE (save_pst)->extern_count = cur_sdx; 3621 PST_PRIVATE (save_pst)->extern_tab = ext_ptr; 3622 for (; --cur_sdx >= 0; ext_ptr++) 3623 { 3624 enum address_class class; 3625 SYMR *psh; 3626 char *name; 3627 CORE_ADDR svalue; 3628 3629 if (ext_ptr->ifd != f_idx) 3630 internal_error (__FILE__, __LINE__, _("failed internal consistency check")); 3631 psh = &ext_ptr->asym; 3632 3633 /* Do not add undefined symbols to the partial symbol table. */ 3634 if (SC_IS_UNDEF (psh->sc) || psh->sc == scNil) 3635 continue; 3636 3637 svalue = psh->value; 3638 switch (psh->sc) 3639 { 3640 case scText: 3641 case scRConst: 3642 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)); 3643 break; 3644 case scData: 3645 case scSData: 3646 case scRData: 3647 case scPData: 3648 case scXData: 3649 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile)); 3650 break; 3651 case scBss: 3652 case scSBss: 3653 svalue += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile)); 3654 break; 3655 } 3656 3657 switch (psh->st) 3658 { 3659 case stNil: 3660 /* These are generated for static symbols in .o files, 3661 ignore them. */ 3662 continue; 3663 case stProc: 3664 case stStaticProc: 3665 /* External procedure symbols have been entered 3666 into the minimal symbol table in pass 2 above. 3667 Ignore them, as parse_external will ignore them too. */ 3668 continue; 3669 case stLabel: 3670 class = LOC_LABEL; 3671 break; 3672 default: 3673 unknown_ext_complaint (debug_info->ssext + psh->iss); 3674 /* Fall through, pretend it's global. */ 3675 case stGlobal: 3676 /* Global common symbols are resolved by the runtime loader, 3677 ignore them. */ 3678 if (SC_IS_COMMON (psh->sc)) 3679 continue; 3680 3681 class = LOC_STATIC; 3682 break; 3683 } 3684 name = debug_info->ssext + psh->iss; 3685 add_psymbol_to_list (name, strlen (name), 3686 VAR_DOMAIN, class, 3687 &objfile->global_psymbols, 3688 0, svalue, 3689 psymtab_language, objfile); 3690 } 3691 } 3692 3693 /* Link pst to FDR. end_psymtab returns NULL if the psymtab was 3694 empty and put on the free list. */ 3695 fdr_to_pst[f_idx].pst = end_psymtab (save_pst, 3696 psymtab_include_list, includes_used, 3697 -1, save_pst->texthigh, 3698 dependency_list, dependencies_used, textlow_not_set); 3699 includes_used = 0; 3700 dependencies_used = 0; 3701 3702 /* The objfile has its functions reordered if this partial symbol 3703 table overlaps any other partial symbol table. 3704 We cannot assume a reordered objfile if a partial symbol table 3705 is contained within another partial symbol table, as partial symbol 3706 tables for include files with executable code are contained 3707 within the partial symbol table for the including source file, 3708 and we do not want to flag the objfile reordered for these cases. 3709 3710 This strategy works well for Irix-5.2 shared libraries, but we 3711 might have to use a more elaborate (and slower) algorithm for 3712 other cases. */ 3713 save_pst = fdr_to_pst[f_idx].pst; 3714 if (save_pst != NULL 3715 && save_pst->textlow != 0 3716 && !(objfile->flags & OBJF_REORDERED)) 3717 { 3718 ALL_OBJFILE_PSYMTABS (objfile, pst) 3719 { 3720 if (save_pst != pst 3721 && save_pst->textlow >= pst->textlow 3722 && save_pst->textlow < pst->texthigh 3723 && save_pst->texthigh > pst->texthigh) 3724 { 3725 objfile->flags |= OBJF_REORDERED; 3726 break; 3727 } 3728 } 3729 } 3730 } 3731 3732 /* Now scan the FDRs for dependencies */ 3733 for (f_idx = 0; f_idx < hdr->ifdMax; f_idx++) 3734 { 3735 fh = f_idx + debug_info->fdr; 3736 pst = fdr_to_pst[f_idx].pst; 3737 3738 if (pst == (struct partial_symtab *) NULL) 3739 continue; 3740 3741 /* This should catch stabs-in-ecoff. */ 3742 if (fh->crfd <= 1) 3743 continue; 3744 3745 /* Skip the first file indirect entry as it is a self dependency 3746 for source files or a reverse .h -> .c dependency for header files. */ 3747 pst->number_of_dependencies = 0; 3748 pst->dependencies = 3749 ((struct partial_symtab **) 3750 obstack_alloc (&objfile->objfile_obstack, 3751 ((fh->crfd - 1) 3752 * sizeof (struct partial_symtab *)))); 3753 for (s_idx = 1; s_idx < fh->crfd; s_idx++) 3754 { 3755 RFDT rh; 3756 3757 (*swap_rfd_in) (cur_bfd, 3758 ((char *) debug_info->external_rfd 3759 + (fh->rfdBase + s_idx) * external_rfd_size), 3760 &rh); 3761 if (rh < 0 || rh >= hdr->ifdMax) 3762 { 3763 complaint (&symfile_complaints, _("bad file number %ld"), rh); 3764 continue; 3765 } 3766 3767 /* Skip self dependencies of header files. */ 3768 if (rh == f_idx) 3769 continue; 3770 3771 /* Do not add to dependeny list if psymtab was empty. */ 3772 if (fdr_to_pst[rh].pst == (struct partial_symtab *) NULL) 3773 continue; 3774 pst->dependencies[pst->number_of_dependencies++] = fdr_to_pst[rh].pst; 3775 } 3776 } 3777 3778 /* Remove the dummy psymtab created for -O3 images above, if it is 3779 still empty, to enable the detection of stripped executables. */ 3780 if (objfile->psymtabs->next == NULL 3781 && objfile->psymtabs->number_of_dependencies == 0 3782 && objfile->psymtabs->n_global_syms == 0 3783 && objfile->psymtabs->n_static_syms == 0) 3784 objfile->psymtabs = NULL; 3785 do_cleanups (old_chain); 3786 } 3787 3788 /* If the current psymbol has an enumerated type, we need to add 3789 all the the enum constants to the partial symbol table. */ 3790 3791 static void 3792 handle_psymbol_enumerators (struct objfile *objfile, FDR *fh, int stype, 3793 CORE_ADDR svalue) 3794 { 3795 const bfd_size_type external_sym_size = debug_swap->external_sym_size; 3796 void (*const swap_sym_in) (bfd *, void *, SYMR *) = debug_swap->swap_sym_in; 3797 char *ext_sym = ((char *) debug_info->external_sym 3798 + ((fh->isymBase + cur_sdx + 1) * external_sym_size)); 3799 SYMR sh; 3800 TIR tir; 3801 3802 switch (stype) 3803 { 3804 case stEnum: 3805 break; 3806 3807 case stBlock: 3808 /* It is an enumerated type if the next symbol entry is a stMember 3809 and its auxiliary index is indexNil or its auxiliary entry 3810 is a plain btNil or btVoid. 3811 Alpha cc -migrate enums are recognized by a zero index and 3812 a zero symbol value. 3813 DU 4.0 cc enums are recognized by a member type of btEnum without 3814 qualifiers and a zero symbol value. */ 3815 (*swap_sym_in) (cur_bfd, ext_sym, &sh); 3816 if (sh.st != stMember) 3817 return; 3818 3819 if (sh.index == indexNil 3820 || (sh.index == 0 && svalue == 0)) 3821 break; 3822 (*debug_swap->swap_tir_in) (fh->fBigendian, 3823 &(debug_info->external_aux 3824 + fh->iauxBase + sh.index)->a_ti, 3825 &tir); 3826 if ((tir.bt != btNil 3827 && tir.bt != btVoid 3828 && (tir.bt != btEnum || svalue != 0)) 3829 || tir.tq0 != tqNil) 3830 return; 3831 break; 3832 3833 default: 3834 return; 3835 } 3836 3837 for (;;) 3838 { 3839 char *name; 3840 3841 (*swap_sym_in) (cur_bfd, ext_sym, &sh); 3842 if (sh.st != stMember) 3843 break; 3844 name = debug_info->ss + cur_fdr->issBase + sh.iss; 3845 3846 /* Note that the value doesn't matter for enum constants 3847 in psymtabs, just in symtabs. */ 3848 add_psymbol_to_list (name, strlen (name), 3849 VAR_DOMAIN, LOC_CONST, 3850 &objfile->static_psymbols, 0, 3851 (CORE_ADDR) 0, psymtab_language, objfile); 3852 ext_sym += external_sym_size; 3853 } 3854 } 3855 3856 /* Get the next symbol. OBJFILE is unused. */ 3857 3858 static char * 3859 mdebug_next_symbol_text (struct objfile *objfile) 3860 { 3861 SYMR sh; 3862 3863 cur_sdx++; 3864 (*debug_swap->swap_sym_in) (cur_bfd, 3865 ((char *) debug_info->external_sym 3866 + ((cur_fdr->isymBase + cur_sdx) 3867 * debug_swap->external_sym_size)), 3868 &sh); 3869 return debug_info->ss + cur_fdr->issBase + sh.iss; 3870 } 3871 3872 /* Ancillary function to psymtab_to_symtab(). Does all the work 3873 for turning the partial symtab PST into a symtab, recurring 3874 first on all dependent psymtabs. The argument FILENAME is 3875 only passed so we can see in debug stack traces what file 3876 is being read. 3877 3878 This function has a split personality, based on whether the 3879 symbol table contains ordinary ecoff symbols, or stabs-in-ecoff. 3880 The flow of control and even the memory allocation differs. FIXME. */ 3881 3882 static void 3883 psymtab_to_symtab_1 (struct partial_symtab *pst, char *filename) 3884 { 3885 bfd_size_type external_sym_size; 3886 bfd_size_type external_pdr_size; 3887 void (*swap_sym_in) (bfd *, void *, SYMR *); 3888 void (*swap_pdr_in) (bfd *, void *, PDR *); 3889 int i; 3890 struct symtab *st = NULL; 3891 FDR *fh; 3892 struct linetable *lines; 3893 CORE_ADDR lowest_pdr_addr = 0; 3894 int last_symtab_ended = 0; 3895 3896 if (pst->readin) 3897 return; 3898 pst->readin = 1; 3899 3900 /* Read in all partial symbtabs on which this one is dependent. 3901 NOTE that we do have circular dependencies, sigh. We solved 3902 that by setting pst->readin before this point. */ 3903 3904 for (i = 0; i < pst->number_of_dependencies; i++) 3905 if (!pst->dependencies[i]->readin) 3906 { 3907 /* Inform about additional files to be read in. */ 3908 if (info_verbose) 3909 { 3910 fputs_filtered (" ", gdb_stdout); 3911 wrap_here (""); 3912 fputs_filtered ("and ", gdb_stdout); 3913 wrap_here (""); 3914 printf_filtered ("%s...", 3915 pst->dependencies[i]->filename); 3916 wrap_here (""); /* Flush output */ 3917 gdb_flush (gdb_stdout); 3918 } 3919 /* We only pass the filename for debug purposes */ 3920 psymtab_to_symtab_1 (pst->dependencies[i], 3921 pst->dependencies[i]->filename); 3922 } 3923 3924 /* Do nothing if this is a dummy psymtab. */ 3925 3926 if (pst->n_global_syms == 0 && pst->n_static_syms == 0 3927 && pst->textlow == 0 && pst->texthigh == 0) 3928 return; 3929 3930 /* Now read the symbols for this symtab */ 3931 3932 cur_bfd = CUR_BFD (pst); 3933 debug_swap = DEBUG_SWAP (pst); 3934 debug_info = DEBUG_INFO (pst); 3935 pending_list = PENDING_LIST (pst); 3936 external_sym_size = debug_swap->external_sym_size; 3937 external_pdr_size = debug_swap->external_pdr_size; 3938 swap_sym_in = debug_swap->swap_sym_in; 3939 swap_pdr_in = debug_swap->swap_pdr_in; 3940 current_objfile = pst->objfile; 3941 cur_fd = FDR_IDX (pst); 3942 fh = ((cur_fd == -1) 3943 ? (FDR *) NULL 3944 : debug_info->fdr + cur_fd); 3945 cur_fdr = fh; 3946 3947 /* See comment in parse_partial_symbols about the @stabs sentinel. */ 3948 processing_gcc_compilation = 0; 3949 if (fh != (FDR *) NULL && fh->csym >= 2) 3950 { 3951 SYMR sh; 3952 3953 (*swap_sym_in) (cur_bfd, 3954 ((char *) debug_info->external_sym 3955 + (fh->isymBase + 1) * external_sym_size), 3956 &sh); 3957 if (strcmp (debug_info->ss + fh->issBase + sh.iss, 3958 stabs_symbol) == 0) 3959 { 3960 /* We indicate that this is a GCC compilation so that certain 3961 features will be enabled in stabsread/dbxread. */ 3962 processing_gcc_compilation = 2; 3963 } 3964 } 3965 3966 if (processing_gcc_compilation != 0) 3967 { 3968 struct gdbarch *gdbarch = get_objfile_arch (pst->objfile); 3969 3970 /* This symbol table contains stabs-in-ecoff entries. */ 3971 3972 /* Parse local symbols first */ 3973 3974 if (fh->csym <= 2) /* FIXME, this blows psymtab->symtab ptr */ 3975 { 3976 current_objfile = NULL; 3977 return; 3978 } 3979 for (cur_sdx = 2; cur_sdx < fh->csym; cur_sdx++) 3980 { 3981 SYMR sh; 3982 char *name; 3983 CORE_ADDR valu; 3984 3985 (*swap_sym_in) (cur_bfd, 3986 (((char *) debug_info->external_sym) 3987 + (fh->isymBase + cur_sdx) * external_sym_size), 3988 &sh); 3989 name = debug_info->ss + fh->issBase + sh.iss; 3990 valu = sh.value; 3991 /* XXX This is a hack. It will go away! */ 3992 if (ECOFF_IS_STAB (&sh) || (name[0] == '#')) 3993 { 3994 int type_code = ECOFF_UNMARK_STAB (sh.index); 3995 3996 /* We should never get non N_STAB symbols here, but they 3997 should be harmless, so keep process_one_symbol from 3998 complaining about them. */ 3999 if (type_code & N_STAB) 4000 { 4001 /* If we found a trailing N_SO with no name, process 4002 it here instead of in process_one_symbol, so we 4003 can keep a handle to its symtab. The symtab 4004 would otherwise be ended twice, once in 4005 process_one_symbol, and once after this loop. */ 4006 if (type_code == N_SO 4007 && last_source_file 4008 && previous_stab_code != (unsigned char) N_SO 4009 && *name == '\000') 4010 { 4011 valu += ANOFFSET (pst->section_offsets, 4012 SECT_OFF_TEXT (pst->objfile)); 4013 previous_stab_code = N_SO; 4014 st = end_symtab (valu, pst->objfile, 4015 SECT_OFF_TEXT (pst->objfile)); 4016 end_stabs (); 4017 last_symtab_ended = 1; 4018 } 4019 else 4020 { 4021 last_symtab_ended = 0; 4022 process_one_symbol (type_code, 0, valu, name, 4023 pst->section_offsets, pst->objfile); 4024 } 4025 } 4026 /* Similarly a hack. */ 4027 else if (name[0] == '#') 4028 { 4029 process_one_symbol (N_SLINE, 0, valu, name, 4030 pst->section_offsets, pst->objfile); 4031 } 4032 if (type_code == N_FUN) 4033 { 4034 /* Make up special symbol to contain 4035 procedure specific info */ 4036 struct mdebug_extra_func_info *e = 4037 ((struct mdebug_extra_func_info *) 4038 obstack_alloc (¤t_objfile->objfile_obstack, 4039 sizeof (struct mdebug_extra_func_info))); 4040 struct symbol *s = new_symbol (MDEBUG_EFI_SYMBOL_NAME); 4041 4042 memset (e, 0, sizeof (struct mdebug_extra_func_info)); 4043 SYMBOL_DOMAIN (s) = LABEL_DOMAIN; 4044 SYMBOL_CLASS (s) = LOC_CONST; 4045 SYMBOL_TYPE (s) = objfile_type (pst->objfile)->builtin_void; 4046 SYMBOL_VALUE_BYTES (s) = (gdb_byte *) e; 4047 e->pdr.framereg = -1; 4048 add_symbol_to_list (s, &local_symbols); 4049 } 4050 } 4051 else if (sh.st == stLabel) 4052 { 4053 if (sh.index == indexNil) 4054 { 4055 /* This is what the gcc2_compiled and __gnu_compiled_* 4056 show up as. So don't complain. */ 4057 ; 4058 } 4059 else 4060 { 4061 /* Handle encoded stab line number. */ 4062 valu += ANOFFSET (pst->section_offsets, SECT_OFF_TEXT (pst->objfile)); 4063 record_line (current_subfile, sh.index, 4064 gdbarch_addr_bits_remove (gdbarch, valu)); 4065 } 4066 } 4067 else if (sh.st == stProc || sh.st == stStaticProc 4068 || sh.st == stStatic || sh.st == stEnd) 4069 /* These are generated by gcc-2.x, do not complain */ 4070 ; 4071 else 4072 complaint (&symfile_complaints, _("unknown stabs symbol %s"), name); 4073 } 4074 4075 if (! last_symtab_ended) 4076 { 4077 st = end_symtab (pst->texthigh, pst->objfile, SECT_OFF_TEXT (pst->objfile)); 4078 end_stabs (); 4079 } 4080 4081 /* There used to be a call to sort_blocks here, but this should not 4082 be necessary for stabs symtabs. And as sort_blocks modifies the 4083 start address of the GLOBAL_BLOCK to the FIRST_LOCAL_BLOCK, 4084 it did the wrong thing if the first procedure in a file was 4085 generated via asm statements. */ 4086 4087 /* Fill in procedure info next. */ 4088 if (fh->cpd > 0) 4089 { 4090 PDR *pr_block; 4091 struct cleanup *old_chain; 4092 char *pdr_ptr; 4093 char *pdr_end; 4094 PDR *pdr_in; 4095 PDR *pdr_in_end; 4096 4097 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); 4098 old_chain = make_cleanup (xfree, pr_block); 4099 4100 pdr_ptr = ((char *) debug_info->external_pdr 4101 + fh->ipdFirst * external_pdr_size); 4102 pdr_end = pdr_ptr + fh->cpd * external_pdr_size; 4103 pdr_in = pr_block; 4104 for (; 4105 pdr_ptr < pdr_end; 4106 pdr_ptr += external_pdr_size, pdr_in++) 4107 { 4108 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); 4109 4110 /* Determine lowest PDR address, the PDRs are not always 4111 sorted. */ 4112 if (pdr_in == pr_block) 4113 lowest_pdr_addr = pdr_in->adr; 4114 else if (pdr_in->adr < lowest_pdr_addr) 4115 lowest_pdr_addr = pdr_in->adr; 4116 } 4117 4118 pdr_in = pr_block; 4119 pdr_in_end = pdr_in + fh->cpd; 4120 for (; pdr_in < pdr_in_end; pdr_in++) 4121 parse_procedure (pdr_in, st, pst); 4122 4123 do_cleanups (old_chain); 4124 } 4125 } 4126 else 4127 { 4128 /* This symbol table contains ordinary ecoff entries. */ 4129 4130 int f_max; 4131 int maxlines; 4132 EXTR *ext_ptr; 4133 4134 if (fh == 0) 4135 { 4136 maxlines = 0; 4137 st = new_symtab ("unknown", 0, pst->objfile); 4138 } 4139 else 4140 { 4141 maxlines = 2 * fh->cline; 4142 st = new_symtab (pst->filename, maxlines, pst->objfile); 4143 4144 /* The proper language was already determined when building 4145 the psymtab, use it. */ 4146 st->language = PST_PRIVATE (pst)->pst_language; 4147 } 4148 4149 psymtab_language = st->language; 4150 4151 lines = LINETABLE (st); 4152 4153 /* Get a new lexical context */ 4154 4155 push_parse_stack (); 4156 top_stack->cur_st = st; 4157 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (st), 4158 STATIC_BLOCK); 4159 BLOCK_START (top_stack->cur_block) = pst->textlow; 4160 BLOCK_END (top_stack->cur_block) = 0; 4161 top_stack->blocktype = stFile; 4162 top_stack->cur_type = 0; 4163 top_stack->procadr = 0; 4164 top_stack->numargs = 0; 4165 found_ecoff_debugging_info = 0; 4166 4167 if (fh) 4168 { 4169 char *sym_ptr; 4170 char *sym_end; 4171 4172 /* Parse local symbols first */ 4173 sym_ptr = ((char *) debug_info->external_sym 4174 + fh->isymBase * external_sym_size); 4175 sym_end = sym_ptr + fh->csym * external_sym_size; 4176 while (sym_ptr < sym_end) 4177 { 4178 SYMR sh; 4179 int c; 4180 4181 (*swap_sym_in) (cur_bfd, sym_ptr, &sh); 4182 c = parse_symbol (&sh, 4183 debug_info->external_aux + fh->iauxBase, 4184 sym_ptr, fh->fBigendian, pst->section_offsets, pst->objfile); 4185 sym_ptr += c * external_sym_size; 4186 } 4187 4188 /* Linenumbers. At the end, check if we can save memory. 4189 parse_lines has to look ahead an arbitrary number of PDR 4190 structures, so we swap them all first. */ 4191 if (fh->cpd > 0) 4192 { 4193 PDR *pr_block; 4194 struct cleanup *old_chain; 4195 char *pdr_ptr; 4196 char *pdr_end; 4197 PDR *pdr_in; 4198 PDR *pdr_in_end; 4199 4200 pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR)); 4201 4202 old_chain = make_cleanup (xfree, pr_block); 4203 4204 pdr_ptr = ((char *) debug_info->external_pdr 4205 + fh->ipdFirst * external_pdr_size); 4206 pdr_end = pdr_ptr + fh->cpd * external_pdr_size; 4207 pdr_in = pr_block; 4208 for (; 4209 pdr_ptr < pdr_end; 4210 pdr_ptr += external_pdr_size, pdr_in++) 4211 { 4212 (*swap_pdr_in) (cur_bfd, pdr_ptr, pdr_in); 4213 4214 /* Determine lowest PDR address, the PDRs are not always 4215 sorted. */ 4216 if (pdr_in == pr_block) 4217 lowest_pdr_addr = pdr_in->adr; 4218 else if (pdr_in->adr < lowest_pdr_addr) 4219 lowest_pdr_addr = pdr_in->adr; 4220 } 4221 4222 parse_lines (fh, pr_block, lines, maxlines, pst, lowest_pdr_addr); 4223 if (lines->nitems < fh->cline) 4224 lines = shrink_linetable (lines); 4225 4226 /* Fill in procedure info next. */ 4227 pdr_in = pr_block; 4228 pdr_in_end = pdr_in + fh->cpd; 4229 for (; pdr_in < pdr_in_end; pdr_in++) 4230 parse_procedure (pdr_in, 0, pst); 4231 4232 do_cleanups (old_chain); 4233 } 4234 } 4235 4236 LINETABLE (st) = lines; 4237 4238 /* .. and our share of externals. 4239 XXX use the global list to speed up things here. how? 4240 FIXME, Maybe quit once we have found the right number of ext's? */ 4241 top_stack->cur_st = st; 4242 top_stack->cur_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (top_stack->cur_st), 4243 GLOBAL_BLOCK); 4244 top_stack->blocktype = stFile; 4245 4246 ext_ptr = PST_PRIVATE (pst)->extern_tab; 4247 for (i = PST_PRIVATE (pst)->extern_count; --i >= 0; ext_ptr++) 4248 parse_external (ext_ptr, fh->fBigendian, pst->section_offsets, pst->objfile); 4249 4250 /* If there are undefined symbols, tell the user. 4251 The alpha has an undefined symbol for every symbol that is 4252 from a shared library, so tell the user only if verbose is on. */ 4253 if (info_verbose && n_undef_symbols) 4254 { 4255 printf_filtered (_("File %s contains %d unresolved references:"), 4256 st->filename, n_undef_symbols); 4257 printf_filtered ("\n\t%4d variables\n\t%4d procedures\n\t%4d labels\n", 4258 n_undef_vars, n_undef_procs, n_undef_labels); 4259 n_undef_symbols = n_undef_labels = n_undef_vars = n_undef_procs = 0; 4260 4261 } 4262 pop_parse_stack (); 4263 4264 st->primary = 1; 4265 4266 sort_blocks (st); 4267 } 4268 4269 /* Now link the psymtab and the symtab. */ 4270 pst->symtab = st; 4271 4272 current_objfile = NULL; 4273 } 4274 4275 /* Ancillary parsing procedures. */ 4276 4277 /* Return 1 if the symbol pointed to by SH has a cross reference 4278 to an opaque aggregate type, else 0. */ 4279 4280 static int 4281 has_opaque_xref (FDR *fh, SYMR *sh) 4282 { 4283 TIR tir; 4284 union aux_ext *ax; 4285 RNDXR rn[1]; 4286 unsigned int rf; 4287 4288 if (sh->index == indexNil) 4289 return 0; 4290 4291 ax = debug_info->external_aux + fh->iauxBase + sh->index; 4292 (*debug_swap->swap_tir_in) (fh->fBigendian, &ax->a_ti, &tir); 4293 if (tir.bt != btStruct && tir.bt != btUnion && tir.bt != btEnum) 4294 return 0; 4295 4296 ax++; 4297 (*debug_swap->swap_rndx_in) (fh->fBigendian, &ax->a_rndx, rn); 4298 if (rn->rfd == 0xfff) 4299 rf = AUX_GET_ISYM (fh->fBigendian, ax + 1); 4300 else 4301 rf = rn->rfd; 4302 if (rf != -1) 4303 return 0; 4304 return 1; 4305 } 4306 4307 /* Lookup the type at relative index RN. Return it in TPP 4308 if found and in any event come up with its name PNAME. 4309 BIGEND says whether aux symbols are big-endian or not (from fh->fBigendian). 4310 Return value says how many aux symbols we ate. */ 4311 4312 static int 4313 cross_ref (int fd, union aux_ext *ax, struct type **tpp, enum type_code type_code, /* Use to alloc new type if none is found. */ 4314 char **pname, int bigend, char *sym_name) 4315 { 4316 RNDXR rn[1]; 4317 unsigned int rf; 4318 int result = 1; 4319 FDR *fh; 4320 char *esh; 4321 SYMR sh; 4322 int xref_fd; 4323 struct mdebug_pending *pend; 4324 4325 *tpp = (struct type *) NULL; 4326 4327 (*debug_swap->swap_rndx_in) (bigend, &ax->a_rndx, rn); 4328 4329 /* Escape index means 'the next one' */ 4330 if (rn->rfd == 0xfff) 4331 { 4332 result++; 4333 rf = AUX_GET_ISYM (bigend, ax + 1); 4334 } 4335 else 4336 { 4337 rf = rn->rfd; 4338 } 4339 4340 /* mips cc uses a rf of -1 for opaque struct definitions. 4341 Set TYPE_FLAG_STUB for these types so that check_typedef will 4342 resolve them if the struct gets defined in another compilation unit. */ 4343 if (rf == -1) 4344 { 4345 *pname = "<undefined>"; 4346 *tpp = init_type (type_code, 0, TYPE_FLAG_STUB, (char *) NULL, current_objfile); 4347 return result; 4348 } 4349 4350 /* mips cc uses an escaped rn->index of 0 for struct return types 4351 of procedures that were compiled without -g. These will always remain 4352 undefined. */ 4353 if (rn->rfd == 0xfff && rn->index == 0) 4354 { 4355 *pname = "<undefined>"; 4356 return result; 4357 } 4358 4359 /* Find the relative file descriptor and the symbol in it. */ 4360 fh = get_rfd (fd, rf); 4361 xref_fd = fh - debug_info->fdr; 4362 4363 if (rn->index >= fh->csym) 4364 { 4365 /* File indirect entry is corrupt. */ 4366 *pname = "<illegal>"; 4367 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); 4368 return result; 4369 } 4370 4371 /* If we have processed this symbol then we left a forwarding 4372 pointer to the type in the pending list. If not, we`ll put 4373 it in a list of pending types, to be processed later when 4374 the file will be. In any event, we collect the name for the 4375 type here. */ 4376 4377 esh = ((char *) debug_info->external_sym 4378 + ((fh->isymBase + rn->index) 4379 * debug_swap->external_sym_size)); 4380 (*debug_swap->swap_sym_in) (cur_bfd, esh, &sh); 4381 4382 /* Make sure that this type of cross reference can be handled. */ 4383 if ((sh.sc != scInfo 4384 || (sh.st != stBlock && sh.st != stTypedef && sh.st != stIndirect 4385 && sh.st != stStruct && sh.st != stUnion 4386 && sh.st != stEnum)) 4387 && (sh.st != stBlock || !SC_IS_COMMON (sh.sc))) 4388 { 4389 /* File indirect entry is corrupt. */ 4390 *pname = "<illegal>"; 4391 bad_rfd_entry_complaint (sym_name, xref_fd, rn->index); 4392 return result; 4393 } 4394 4395 *pname = debug_info->ss + fh->issBase + sh.iss; 4396 4397 pend = is_pending_symbol (fh, esh); 4398 if (pend) 4399 *tpp = pend->t; 4400 else 4401 { 4402 /* We have not yet seen this type. */ 4403 4404 if ((sh.iss == 0 && sh.st == stTypedef) || sh.st == stIndirect) 4405 { 4406 TIR tir; 4407 4408 /* alpha cc puts out a stTypedef with a sh.iss of zero for 4409 two cases: 4410 a) forward declarations of structs/unions/enums which are not 4411 defined in this compilation unit. 4412 For these the type will be void. This is a bad design decision 4413 as cross referencing across compilation units is impossible 4414 due to the missing name. 4415 b) forward declarations of structs/unions/enums/typedefs which 4416 are defined later in this file or in another file in the same 4417 compilation unit. Irix5 cc uses a stIndirect symbol for this. 4418 Simply cross reference those again to get the true type. 4419 The forward references are not entered in the pending list and 4420 in the symbol table. */ 4421 4422 (*debug_swap->swap_tir_in) (bigend, 4423 &(debug_info->external_aux 4424 + fh->iauxBase + sh.index)->a_ti, 4425 &tir); 4426 if (tir.tq0 != tqNil) 4427 complaint (&symfile_complaints, 4428 _("illegal tq0 in forward typedef for %s"), sym_name); 4429 switch (tir.bt) 4430 { 4431 case btVoid: 4432 *tpp = init_type (type_code, 0, 0, (char *) NULL, 4433 current_objfile); 4434 *pname = "<undefined>"; 4435 break; 4436 4437 case btStruct: 4438 case btUnion: 4439 case btEnum: 4440 cross_ref (xref_fd, 4441 (debug_info->external_aux 4442 + fh->iauxBase + sh.index + 1), 4443 tpp, type_code, pname, 4444 fh->fBigendian, sym_name); 4445 break; 4446 4447 case btTypedef: 4448 /* Follow a forward typedef. This might recursively 4449 call cross_ref till we get a non typedef'ed type. 4450 FIXME: This is not correct behaviour, but gdb currently 4451 cannot handle typedefs without type copying. Type 4452 copying is impossible as we might have mutual forward 4453 references between two files and the copied type would not 4454 get filled in when we later parse its definition. */ 4455 *tpp = parse_type (xref_fd, 4456 debug_info->external_aux + fh->iauxBase, 4457 sh.index, 4458 (int *) NULL, 4459 fh->fBigendian, 4460 debug_info->ss + fh->issBase + sh.iss); 4461 add_pending (fh, esh, *tpp); 4462 break; 4463 4464 default: 4465 complaint (&symfile_complaints, 4466 _("illegal bt %d in forward typedef for %s"), tir.bt, 4467 sym_name); 4468 *tpp = init_type (type_code, 0, 0, (char *) NULL, 4469 current_objfile); 4470 break; 4471 } 4472 return result; 4473 } 4474 else if (sh.st == stTypedef) 4475 { 4476 /* Parse the type for a normal typedef. This might recursively call 4477 cross_ref till we get a non typedef'ed type. 4478 FIXME: This is not correct behaviour, but gdb currently 4479 cannot handle typedefs without type copying. But type copying is 4480 impossible as we might have mutual forward references between 4481 two files and the copied type would not get filled in when 4482 we later parse its definition. */ 4483 *tpp = parse_type (xref_fd, 4484 debug_info->external_aux + fh->iauxBase, 4485 sh.index, 4486 (int *) NULL, 4487 fh->fBigendian, 4488 debug_info->ss + fh->issBase + sh.iss); 4489 } 4490 else 4491 { 4492 /* Cross reference to a struct/union/enum which is defined 4493 in another file in the same compilation unit but that file 4494 has not been parsed yet. 4495 Initialize the type only, it will be filled in when 4496 it's definition is parsed. */ 4497 *tpp = init_type (type_code, 0, 0, (char *) NULL, current_objfile); 4498 } 4499 add_pending (fh, esh, *tpp); 4500 } 4501 4502 /* We used one auxent normally, two if we got a "next one" rf. */ 4503 return result; 4504 } 4505 4506 4507 /* Quick&dirty lookup procedure, to avoid the MI ones that require 4508 keeping the symtab sorted */ 4509 4510 static struct symbol * 4511 mylookup_symbol (char *name, struct block *block, 4512 domain_enum domain, enum address_class class) 4513 { 4514 struct dict_iterator iter; 4515 int inc; 4516 struct symbol *sym; 4517 4518 inc = name[0]; 4519 ALL_BLOCK_SYMBOLS (block, iter, sym) 4520 { 4521 if (SYMBOL_LINKAGE_NAME (sym)[0] == inc 4522 && SYMBOL_DOMAIN (sym) == domain 4523 && SYMBOL_CLASS (sym) == class 4524 && strcmp (SYMBOL_LINKAGE_NAME (sym), name) == 0) 4525 return sym; 4526 } 4527 4528 block = BLOCK_SUPERBLOCK (block); 4529 if (block) 4530 return mylookup_symbol (name, block, domain, class); 4531 return 0; 4532 } 4533 4534 4535 /* Add a new symbol S to a block B. */ 4536 4537 static void 4538 add_symbol (struct symbol *s, struct symtab *symtab, struct block *b) 4539 { 4540 SYMBOL_SYMTAB (s) = symtab; 4541 dict_add_symbol (BLOCK_DICT (b), s); 4542 } 4543 4544 /* Add a new block B to a symtab S */ 4545 4546 static void 4547 add_block (struct block *b, struct symtab *s) 4548 { 4549 struct blockvector *bv = BLOCKVECTOR (s); 4550 4551 bv = (struct blockvector *) xrealloc ((void *) bv, 4552 (sizeof (struct blockvector) 4553 + BLOCKVECTOR_NBLOCKS (bv) 4554 * sizeof (bv->block))); 4555 if (bv != BLOCKVECTOR (s)) 4556 BLOCKVECTOR (s) = bv; 4557 4558 BLOCKVECTOR_BLOCK (bv, BLOCKVECTOR_NBLOCKS (bv)++) = b; 4559 } 4560 4561 /* Add a new linenumber entry (LINENO,ADR) to a linevector LT. 4562 MIPS' linenumber encoding might need more than one byte 4563 to describe it, LAST is used to detect these continuation lines. 4564 4565 Combining lines with the same line number seems like a bad idea. 4566 E.g: There could be a line number entry with the same line number after the 4567 prologue and GDB should not ignore it (this is a better way to find 4568 a prologue than mips_skip_prologue). 4569 But due to the compressed line table format there are line number entries 4570 for the same line which are needed to bridge the gap to the next 4571 line number entry. These entries have a bogus address info with them 4572 and we are unable to tell them from intended duplicate line number 4573 entries. 4574 This is another reason why -ggdb debugging format is preferable. */ 4575 4576 static int 4577 add_line (struct linetable *lt, int lineno, CORE_ADDR adr, int last) 4578 { 4579 /* DEC c89 sometimes produces zero linenos which confuse gdb. 4580 Change them to something sensible. */ 4581 if (lineno == 0) 4582 lineno = 1; 4583 if (last == 0) 4584 last = -2; /* make sure we record first line */ 4585 4586 if (last == lineno) /* skip continuation lines */ 4587 return lineno; 4588 4589 lt->item[lt->nitems].line = lineno; 4590 lt->item[lt->nitems++].pc = adr << 2; 4591 return lineno; 4592 } 4593 4594 /* Sorting and reordering procedures */ 4595 4596 /* Blocks with a smaller low bound should come first */ 4597 4598 static int 4599 compare_blocks (const void *arg1, const void *arg2) 4600 { 4601 LONGEST addr_diff; 4602 struct block **b1 = (struct block **) arg1; 4603 struct block **b2 = (struct block **) arg2; 4604 4605 addr_diff = (BLOCK_START ((*b1))) - (BLOCK_START ((*b2))); 4606 if (addr_diff == 0) 4607 return (BLOCK_END ((*b2))) - (BLOCK_END ((*b1))); 4608 return addr_diff; 4609 } 4610 4611 /* Sort the blocks of a symtab S. 4612 Reorder the blocks in the blockvector by code-address, 4613 as required by some MI search routines */ 4614 4615 static void 4616 sort_blocks (struct symtab *s) 4617 { 4618 struct blockvector *bv = BLOCKVECTOR (s); 4619 4620 if (BLOCKVECTOR_NBLOCKS (bv) <= 2) 4621 { 4622 /* Cosmetic */ 4623 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) == 0) 4624 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 0; 4625 if (BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) == 0) 4626 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 0; 4627 return; 4628 } 4629 /* 4630 * This is very unfortunate: normally all functions are compiled in 4631 * the order they are found, but if the file is compiled -O3 things 4632 * are very different. It would be nice to find a reliable test 4633 * to detect -O3 images in advance. 4634 */ 4635 if (BLOCKVECTOR_NBLOCKS (bv) > 3) 4636 qsort (&BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK), 4637 BLOCKVECTOR_NBLOCKS (bv) - FIRST_LOCAL_BLOCK, 4638 sizeof (struct block *), 4639 compare_blocks); 4640 4641 { 4642 CORE_ADDR high = 0; 4643 int i, j = BLOCKVECTOR_NBLOCKS (bv); 4644 4645 for (i = FIRST_LOCAL_BLOCK; i < j; i++) 4646 if (high < BLOCK_END (BLOCKVECTOR_BLOCK (bv, i))) 4647 high = BLOCK_END (BLOCKVECTOR_BLOCK (bv, i)); 4648 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = high; 4649 } 4650 4651 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)) = 4652 BLOCK_START (BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK)); 4653 4654 BLOCK_START (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 4655 BLOCK_START (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 4656 BLOCK_END (BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK)) = 4657 BLOCK_END (BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK)); 4658 } 4659 4660 4661 /* Constructor/restructor/destructor procedures */ 4662 4663 /* Allocate a new symtab for NAME. Needs an estimate of how many 4664 linenumbers MAXLINES we'll put in it */ 4665 4666 static struct symtab * 4667 new_symtab (char *name, int maxlines, struct objfile *objfile) 4668 { 4669 struct symtab *s = allocate_symtab (name, objfile); 4670 4671 LINETABLE (s) = new_linetable (maxlines); 4672 4673 /* All symtabs must have at least two blocks */ 4674 BLOCKVECTOR (s) = new_bvect (2); 4675 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK) 4676 = new_block (NON_FUNCTION_BLOCK); 4677 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK) 4678 = new_block (NON_FUNCTION_BLOCK); 4679 BLOCK_SUPERBLOCK (BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK)) = 4680 BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK); 4681 4682 s->free_code = free_linetable; 4683 s->debugformat = obsavestring ("ECOFF", 5, 4684 &objfile->objfile_obstack); 4685 return (s); 4686 } 4687 4688 /* Allocate a new partial_symtab NAME */ 4689 4690 static struct partial_symtab * 4691 new_psymtab (char *name, struct objfile *objfile) 4692 { 4693 struct partial_symtab *psymtab; 4694 4695 psymtab = allocate_psymtab (name, objfile); 4696 psymtab->section_offsets = objfile->section_offsets; 4697 4698 /* Keep a backpointer to the file's symbols */ 4699 4700 psymtab->read_symtab_private = ((char *) 4701 obstack_alloc (&objfile->objfile_obstack, 4702 sizeof (struct symloc))); 4703 memset (psymtab->read_symtab_private, 0, sizeof (struct symloc)); 4704 CUR_BFD (psymtab) = cur_bfd; 4705 DEBUG_SWAP (psymtab) = debug_swap; 4706 DEBUG_INFO (psymtab) = debug_info; 4707 PENDING_LIST (psymtab) = pending_list; 4708 4709 /* The way to turn this into a symtab is to call... */ 4710 psymtab->read_symtab = mdebug_psymtab_to_symtab; 4711 return (psymtab); 4712 } 4713 4714 4715 /* Allocate a linetable array of the given SIZE. Since the struct 4716 already includes one item, we subtract one when calculating the 4717 proper size to allocate. */ 4718 4719 static struct linetable * 4720 new_linetable (int size) 4721 { 4722 struct linetable *l; 4723 4724 size = (size - 1) * sizeof (l->item) + sizeof (struct linetable); 4725 l = (struct linetable *) xmalloc (size); 4726 l->nitems = 0; 4727 return l; 4728 } 4729 4730 /* Oops, too big. Shrink it. This was important with the 2.4 linetables, 4731 I am not so sure about the 3.4 ones. 4732 4733 Since the struct linetable already includes one item, we subtract one when 4734 calculating the proper size to allocate. */ 4735 4736 static struct linetable * 4737 shrink_linetable (struct linetable *lt) 4738 { 4739 4740 return (struct linetable *) xrealloc ((void *) lt, 4741 (sizeof (struct linetable) 4742 + ((lt->nitems - 1) 4743 * sizeof (lt->item)))); 4744 } 4745 4746 /* Allocate and zero a new blockvector of NBLOCKS blocks. */ 4747 4748 static struct blockvector * 4749 new_bvect (int nblocks) 4750 { 4751 struct blockvector *bv; 4752 int size; 4753 4754 size = sizeof (struct blockvector) + nblocks * sizeof (struct block *); 4755 bv = (struct blockvector *) xzalloc (size); 4756 4757 BLOCKVECTOR_NBLOCKS (bv) = nblocks; 4758 4759 return bv; 4760 } 4761 4762 /* Allocate and zero a new block, and set its BLOCK_DICT. If function 4763 is non-zero, assume the block is associated to a function, and make 4764 sure that the symbols are stored linearly; otherwise, store them 4765 hashed. */ 4766 4767 static struct block * 4768 new_block (enum block_type type) 4769 { 4770 /* FIXME: carlton/2003-09-11: This should use allocate_block to 4771 allocate the block. Which, in turn, suggests that the block 4772 should be allocated on an obstack. */ 4773 struct block *retval = xzalloc (sizeof (struct block)); 4774 4775 if (type == FUNCTION_BLOCK) 4776 BLOCK_DICT (retval) = dict_create_linear_expandable (); 4777 else 4778 BLOCK_DICT (retval) = dict_create_hashed_expandable (); 4779 4780 return retval; 4781 } 4782 4783 /* Create a new symbol with printname NAME */ 4784 4785 static struct symbol * 4786 new_symbol (char *name) 4787 { 4788 struct symbol *s = ((struct symbol *) 4789 obstack_alloc (¤t_objfile->objfile_obstack, 4790 sizeof (struct symbol))); 4791 4792 memset (s, 0, sizeof (*s)); 4793 SYMBOL_LANGUAGE (s) = psymtab_language; 4794 SYMBOL_SET_NAMES (s, name, strlen (name), current_objfile); 4795 return s; 4796 } 4797 4798 /* Create a new type with printname NAME */ 4799 4800 static struct type * 4801 new_type (char *name) 4802 { 4803 struct type *t; 4804 4805 t = alloc_type (current_objfile); 4806 TYPE_NAME (t) = name; 4807 TYPE_CPLUS_SPECIFIC (t) = (struct cplus_struct_type *) &cplus_struct_default; 4808 return t; 4809 } 4810 4811 /* Read ECOFF debugging information from a BFD section. This is 4812 called from elfread.c. It parses the section into a 4813 ecoff_debug_info struct, and then lets the rest of the file handle 4814 it as normal. */ 4815 4816 void 4817 elfmdebug_build_psymtabs (struct objfile *objfile, 4818 const struct ecoff_debug_swap *swap, asection *sec) 4819 { 4820 bfd *abfd = objfile->obfd; 4821 struct ecoff_debug_info *info; 4822 struct cleanup *back_to; 4823 4824 /* FIXME: It's not clear whether we should be getting minimal symbol 4825 information from .mdebug in an ELF file, or whether we will. 4826 Re-initialize the minimal symbol reader in case we do. */ 4827 4828 init_minimal_symbol_collection (); 4829 back_to = make_cleanup_discard_minimal_symbols (); 4830 4831 info = ((struct ecoff_debug_info *) 4832 obstack_alloc (&objfile->objfile_obstack, 4833 sizeof (struct ecoff_debug_info))); 4834 4835 if (!(*swap->read_debug_info) (abfd, sec, info)) 4836 error (_("Error reading ECOFF debugging information: %s"), 4837 bfd_errmsg (bfd_get_error ())); 4838 4839 mdebug_build_psymtabs (objfile, swap, info); 4840 4841 install_minimal_symbols (objfile); 4842 do_cleanups (back_to); 4843 } 4844 4845 void 4846 _initialize_mdebugread (void) 4847 { 4848 basic_type_data = register_objfile_data (); 4849 } 4850